msdsearch_soap.h

//gsoap ns service name: msdsearch_soap_service 
//gsoap ns service namespace: urn:msdsearch_soap_service 
//gsoap ns service location: http://www.ebi.ac.uk/msd-srv/ssm/cgi-bin/ws   ///http://www.ebi.ac.uk/msd-srv/msdsoap
//gsoap ns service executable: msdsearch_soap_service.cgi   ///msdsearch_soap_service 
//gsoap ns schema namespace: urn:msdsearch_soap_service
//gsoap t schema namespace: urn:msdsearch_soap_types
//gsoap h schema namespace: urn:msdsearch_soap_handles

//
//  SOAP Header: used to exchange stateful object handles
//



#include <fstream>
extern class ofstream; // transient (external) type

#include <iostream>
extern class std::ostream;      // transient (external) type


#include "Lpp.hh"
extern class let;  // transient (external) type

#define OTL_ORA8I
#include "otlv4.h"
extern class msdbStream; // transient (external) type



        

struct SOAP_ENV__Header
{ mustUnderstand unsigned int h__handle;
};

enum t__object                  // object types:
{ ROOT,                                 // t__root object
  CONNECT,
  QUERY,
  RESULTSET
};

enum t__status                  // remote object status:
{ OK,                                   // ok 0
  INVALID,                              // invalid handle (wrong type of object or lease expired) 1
  NOTFOUND,                             // lookup operation not successful 2
  RETRY,                                        // cannot create new object: try later 3
  NOCONNECT,
  NORESULT,
  NOQUERY
};

class t__root
{ public:
  struct soap *soap;    // points to current gSOAP environment that created this object
  enum t__object object;                // object type
  char *name;                           // object name for lookup operation (optional)
  unsigned int handle;                  // internal handle
  time_t lease;                         // lease expiration time
  t__root();
  virtual ~t__root();
  virtual void renew();                 // to renew lease
 };

class t__connect: public t__root
{ public:
  char* dbserver;
  char* username;
  char* password;
  t__connect();
  virtual ~t__connect();
  void  set(char* host, char* usern, char* pass);                       
  void  get();
};







//
//Server-side connect class derived from root

typedef let let;

class xsd__anyType
{ public:
  char *__item;         // default is string, also to hold mixed-content when receiving typeless XML
  struct soap *soap;    // points to current gSOAP environment that created this object
  xsd__anyType();
//  xsd__anyType(xsd__anyType& src);
  virtual ~xsd__anyType();
  virtual xsd__anyType*& operator[](int i);
   virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  let msd_sym; //transient field 
  let msd_val; //transient field 
  virtual void set(char* s);
 
};

class xsd__anySimpleType: public xsd__anyType
{ public:
  xsd__anySimpleType();
//  xsd__anySimpleType(xsd__anySimpleType& src);
  virtual ~xsd__anySimpleType();
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
};

class xsd__anyURI: public xsd__anySimpleType
{ public:
  xsd__anyURI();
//  xsd__anyURI(xsd__anyURI& src);
  virtual ~xsd__anyURI();
  xsd__anyURI(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
}; 

class xsd__boolean: public xsd__anySimpleType
{ public:
  bool __item;
  xsd__boolean();
//  xsd__boolean(xsd__boolean& src);
  virtual ~xsd__boolean();
  xsd__boolean(bool b);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(bool& b);
}; 

class xsd__date: public xsd__anySimpleType      // requires "CCYY-MM-DD" string values
{ public:
  xsd__date();
//  xsd__date(xsd__date& src);
  virtual ~xsd__date();
  xsd__date(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
};

class xsd__dateTime: public xsd__anySimpleType
{ public:
  time_t __item;                // remove time_t __item to use char*__item with "CCYY-MM-DDThh:mm:ssi" for dates outside the range 1902-2037
  xsd__dateTime();
//  xsd__dateTime(xsd__dateTime& src);
  virtual ~xsd__dateTime();
  xsd__dateTime(time_t t);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(time_t& t);
};

class xsd__double: public xsd__anySimpleType
{ public:
  double __item;
  xsd__double();
//  xsd__double(xsd__double& src);
  virtual ~xsd__double();
  xsd__double(double d);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(double& d);
}; 

class xsd__duration: public xsd__anySimpleType  // requires "PnYnMnDTnHnMnS" string values
{ public:
  xsd__duration();
//  xsd__duration(xsd__duration& src);
  virtual ~xsd__duration();
  xsd__duration(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s);
};

class xsd__float: public xsd__anySimpleType
{ public:
  float __item;
  xsd__float();
//  xsd__float(xsd__float& src);
  virtual ~xsd__float();
  xsd__float(float f);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(float& f);
}; 

class xsd__time: public xsd__anySimpleType      // requires "hh:mm:ss" string values
{ public:
  xsd__time();
//  xsd__time(xsd__time& src);
  virtual ~xsd__time();
  xsd__time(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
};

class xsd__string: public xsd__anySimpleType
{ public:
  xsd__string();
//  xsd__string(xsd__string& src);
  xsd__string(char *s);
  xsd__string(int size);
  virtual ~xsd__string();
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(char* s);

}; 

class xsd__normalizedString: public xsd__string // requires strings without CR, LF, TAB
{ public:
  xsd__normalizedString();
//  xsd__normalizedString(xsd__normalizedString& src);
  xsd__normalizedString(char *s);
  virtual ~xsd__normalizedString();
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
}; 

class xsd__token: public xsd__normalizedString          // requires strings without CR, LF, TAB, no leading/trailing spaces, and no sequences of more than one space
{ public:
  xsd__token();
//  xsd__token(xsd__token& src);
  xsd__token(char *s);
  virtual ~xsd__token();
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
}; 

class xsd__decimal: public xsd__anySimpleType   // requires decimal as string values, can use double, but possible loss of precision
{ public:
  xsd__decimal();
//xsd__decimal(xsd__decimal& src);
  virtual ~xsd__decimal();
  xsd__decimal(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
};

class xsd__integer: public xsd__decimal // requires integer as string values, can use loong long, but possible loss of data
{ public:
  xsd__integer();
//xsd__integer(xsd__integer& src);
  virtual ~xsd__integer();
  xsd__integer(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
};

class xsd__nonPositiveInteger: public xsd__integer      // requires non-positive integer as string values
{ public:
  xsd__nonPositiveInteger();
//xsd__nonPositiveInteger(xsd__nonPositiveInteger& src);
  virtual ~xsd__nonPositiveInteger();
  xsd__nonPositiveInteger(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
}; 

class xsd__negativeInteger: public xsd__nonPositiveInteger      // requires negative integer as string values
{ public:
        xsd__negativeInteger();
//xsd__negativeInteger(xsd__negativeInteger& src);
  virtual ~xsd__negativeInteger();
  xsd__negativeInteger(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
}; 

class xsd__nonNegativeInteger: public xsd__integer      // requires non-negative integer as string values
{ public:
  xsd__nonNegativeInteger();
//xsd__nonNegativeInteger(xsd__nonNegativeInteger& src);
  virtual ~xsd__nonNegativeInteger();
  xsd__nonNegativeInteger(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
}; 

class xsd__positiveInteger: public xsd__nonNegativeInteger      // requires positive integer as string values
{ public:
  xsd__positiveInteger();
//xsd__positiveInteger(xsd__positiveInteger& src);
  virtual ~xsd__positiveInteger();
  xsd__positiveInteger(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
}; 

class xsd__long: public xsd__integer
{ public:
  LONG64 __item;
  xsd__long();
//  xsd__long(xsd__long& src);
  virtual ~xsd__long();
  xsd__long(LONG64 ll);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(LONG64& ll);
}; 

class xsd__int: public xsd__long
{ public:
  int __item;
  xsd__int();
//  xsd__int(xsd__int& src);
  virtual ~xsd__int();
  xsd__int(int i);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(int& i);
}; 

class xsd__short: public xsd__int
{ public:
  short __item;
  xsd__short();
//  xsd__short(xsd__short& src);
  virtual ~xsd__short();
  xsd__short(short h);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(short& h);
}; 

class xsd__byte: public xsd__short
{ public:
  char __item;
  xsd__byte();
//  xsd__byte(xsd__byte& src);
  virtual ~xsd__byte();
  xsd__byte(char c);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(char c);
}; 

class xsd__unsignedLong: public xsd__nonNegativeInteger
{ public:
  ULONG64 __item;
  xsd__unsignedLong();
//  xsd__unsignedLong(xsd__unsignedLong& src);
  virtual ~xsd__unsignedLong();
  xsd__unsignedLong(ULONG64 ull);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(ULONG64& ull);
}; 

class xsd__unsignedInt: public xsd__unsignedLong
{ public:
  unsigned int __item;
  xsd__unsignedInt();
//  xsd__unsignedInt(xsd__unsignedInt& src);
  virtual ~xsd__unsignedInt();
  xsd__unsignedInt(unsigned int ui);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(unsigned int& ui);
}; 

class xsd__unsignedShort: public xsd__unsignedInt
{ public:
  unsigned short __item;
  xsd__unsignedShort();
//  xsd__unsignedShort(xsd__unsignedShort& src);
  virtual ~xsd__unsignedShort();
  xsd__unsignedShort(unsigned short uh);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(unsigned short& uh);
}; 

class xsd__unsignedByte: public xsd__unsignedShort
{ public:
  unsigned char __item;
  xsd__unsignedByte();
//  xsd__unsignedByte(xsd__unsignedByte& src);
  virtual ~xsd__unsignedByte();
  xsd__unsignedByte(unsigned char uc);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(unsigned char uc);
}; 

class xsd__base64Binary: public xsd__anySimpleType
{ public:
  unsigned char *__ptr;
  int __size;
  char *id;
  char *type;
  char *options;
  xsd__base64Binary();
//  xsd__base64Binary(xsd__base64Binary& src);
  virtual ~xsd__base64Binary();
  xsd__base64Binary(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(char* s);
};


class SOAP_ENC__base64
{ public:
   unsigned char *__ptr;
   int __size;
};





class xsd__hexBinary: public xsd__anySimpleType
{ public:
  unsigned char *__ptr;
  int __size;
  xsd__hexBinary();
//  xsd__hexBinary(xsd__hexBinary& src);
  virtual ~xsd__hexBinary();
  xsd__hexBinary(char *s);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  virtual void set(char* s);
};

class array: public xsd__anyType
{ public:
  xsd__anyType **__ptr;
  int __size;
  array();
//  array(array& src);
  virtual ~array();
  array(int n);
  virtual xsd__anyType*& operator[](int i);
  virtual void print(std::ostream &s) const;
  virtual void fprint(ofstream& s) const;
  virtual void setst (msdbStream& s); 
  virtual void getst (msdbStream& s); 
  
};


class t__resultset: public t__root
{ let contents;
  int size;
  public:
  int hasdata;
  char* conn_name;
  char* query_name;
  int cols;
  int rows;
  xsd__anyType **  prs;
  array r;
  t__resultset();
  virtual ~t__resultset();
  int getSize(); 
  void addEntity(let);
  void setValue(let, let, let);
  let getValue(let, let);
  void delEntity(let);
  void set(t__connect * pcon, char* queryn);    
  void get();
};

class ns__msdGetResultResponse {
   public: 
        t__resultset rs;
};

class t__query: public t__root
{ public:
  int exf;
  char* conn_name;
  char* result_name;
  char* loginstr;
  char* query_stm;
  t__query();
  virtual ~t__query();
  void set(t__connect * pcon, t__resultset * prs, char* qry);                   // to init / set the connect
  void get();
                                
};



struct _item 
{ xsd__anyType *key;
  xsd__anyType *value;
};

struct a__Map 
{ struct _item *__ptr;
  int __size;
};

struct ArrayOfMap 
{ struct a__Map **__ptr;
  int __size;
};

// Vector and Matrix Definitions

class t__rvec // dynamic array of type SOAP-ENC:Array with arrayType="double[]"
{ public:
        xsd__double             *__ptr; // pointer to array of double
        int                     __size; // number of elements pointed to
        int                     __offset;
        struct soap             *soap;  // gSOAP env. instance was created
        t__rvec();
        t__rvec(struct soap *env);
        t__rvec(struct soap *env, int size);
        t__rvec(struct soap *env, int start, int end);
        virtual int     start(); // index of first element (=__offset)
        virtual int     end();   // index of last element
        virtual int     size();  // vector size
        virtual void resize(int size);
        virtual void resize(int start, int end);
        virtual ~t__rvec();
        virtual xsd__double& operator[](int i);
        virtual xsd__double operator()(int i);
        //virtual void          print();
};
class t__ivec // dynamic array of type SOAP-ENC:Array with arrayType="int[]"
{ public:
        xsd__int                *__ptr; // pointer to array of int
        int                     __size; // number of elements pointed to
        int                     __offset;
        struct soap             *soap;  // gSOAP env. instance was created
        t__ivec();
        t__ivec(struct soap *env);
        t__ivec(struct soap *env, int size);
        t__ivec(struct soap *env, int start, int end);
        virtual int     start(); // index of first element (=__offset)
        virtual int     end();   // index of last element
        virtual int     size();  // vector size
        virtual void resize(int size);
        virtual void resize(int start, int end);
        virtual ~t__ivec();
        virtual xsd__int& operator[](int i);
        virtual xsd__int operator()(int i);
        //virtual void          print();
};

class t__rmat // dynamic array of type SOAP-ENC:Array with arrayType="double[][]"
{ public:
        t__rvec                 *__ptr; // pointer to array of vecs
        int                     __size; // number of vecs pointed to
        int                     __offset;
        struct soap             *soap;  // gSOAP env. instance was created
        t__rmat();
        t__rmat(struct soap *env);
        t__rmat(struct soap *env, int rows);
        t__rmat(struct soap *env, int rows, int cols);
        t__rmat(struct soap *env, int rowstart, int rowend, int colstart, int colend);
        virtual int     start();
        virtual int     end();
        virtual int     size();
        virtual void resize(int rows, int cols);
        virtual void resize(int rowstart, int rowend, int colstart, int colend);
        virtual ~t__rmat();
        virtual t__rvec&                operator[](int i);
        virtual xsd__double             operator()(int i, int j);
        //virtual void          print();
};
class t__imat // dynamic array of type SOAP-ENC:Array with arrayType="int[][]"
{ public:
        t__ivec                 *__ptr; // pointer to array of t__ivecs
        int                     __size; // number of t__ivecs pointed to
        int                     __offset;
        struct soap             *soap;  // gSOAP env. instance was created
        t__imat();
        t__imat(struct soap *env);
        t__imat(struct soap *env, int rows, int cols);
        t__imat(struct soap *env, int rowstart, int rowend, int colstart, int colend);
        virtual int     start();
        virtual int     end();
        virtual int     size();
        virtual void resize(int rows, int cols);
        virtual void resize(int rowstart, int rowend, int colstart, int colend);
        virtual                 ~t__imat();
        virtual t__ivec&                operator[](int i);
        virtual xsd__int                operator()(int i, int j);
        //virtual void          print();
};
struct  StrVec
{       xsd__string     *__ptr;
        int             __size;
};
struct  RealVec
{       xsd__float      *__ptr;
        int             __size;
};
struct  IntVec
{       xsd__int        *__ptr;
        int             __size;
};
struct  RealMat
{       struct  RealVec * __ptr;
        int             __size;
};



#import "soapchem.msd"






int ns__msdSSM(int numofpars, array *inparams, int &result);

int ns__msdSSMParser(char* sessionid, char* dbserver, int &result);

int ns__msdFasta(int numofpars, array *inparams, int &result);

int ns__msdFastaParser (char* sessionid, char* dbserver, int &result);

int ns__msdAppServer(int numofpars, array *inparams, int &result);

/*
Option  Description  
-1  Use SOAP 1.1 namespace (default)  
-2  Use SOAP 1.2 namespace  
-h  Print a brief usage message  
-c  Save files using extension .c instead of .cpp  
-i  Interpret #include and #define directives  
-m  Generate code that requires array/binary classes to explicitly free malloced array  
-d < path >  Save sources in directory specified by < path >  
-p < name >  Save sources with file name prefix < name > instead of ``soap''  
 

For example 

soapcpp2 -cd '../projects' -pmy file.h  
*/

/*  ./soapcpp2 -2 -i -pmsdsearch_soap msdsearch_soap.h */

---