wsdlstub.h

linux下简单对象应用协议的开发库

	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	virtual ~xs__list() { }
};
#endif

#ifndef SOAP_TYPE_xs__union
#define SOAP_TYPE_xs__union (28)
/* xs:union */
class SOAP_CMAC xs__union
{
public:
	char *memberTypes;	/* optional attribute */
	std::vector<xs__simpleType >simpleType;	/* optional element of type xs:simpleType */
	int traverse(xs__schema &_param_34);	/* transient */
public:
	virtual int soap_type() const { return 28; } /* = unique id SOAP_TYPE_xs__union */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	         xs__union() : memberTypes(NULL) { }
	virtual ~xs__union() { }
};
#endif

#ifndef SOAP_TYPE_xs__complexContent
#define SOAP_TYPE_xs__complexContent (148)
/* xs:complexContent */
class SOAP_CMAC xs__complexContent
{
public:
	bool mixed;	/* optional attribute */
	xs__extension *extension;	/* optional element of type xs:extension */
	xs__restriction *restriction;	/* optional element of type xs:restriction */
	int traverse(xs__schema &_param_35);	/* transient */
public:
	virtual int soap_type() const { return 148; } /* = unique id SOAP_TYPE_xs__complexContent */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	         xs__complexContent() : mixed((bool)0), extension(NULL), restriction(NULL) { }
	virtual ~xs__complexContent() { }
};
#endif

#ifndef SOAP_TYPE_xs__complexType
#define SOAP_TYPE_xs__complexType (22)
/* xs:complexType */
class SOAP_CMAC xs__complexType
{
public:
	char *name;	/* optional attribute */
	bool abstract;	/* optional attribute */
	bool mixed;	/* optional attribute */
	xs__annotation *annotation;	/* optional element of type xs:annotation */
	xs__simpleContent *simpleContent;	/* optional element of type xs:simpleContent */
	xs__complexContent *complexContent;	/* optional element of type xs:complexContent */
	xs__all *all;	/* optional element of type xs:all */
	xs__choice *choice;	/* optional element of type xs:choice */
	xs__sequence *sequence;	/* optional element of type xs:sequence */
	xs__any *any;	/* optional element of type xs:any */
	std::vector<xs__attribute >attribute;	/* optional element of type xs:attribute */
	std::vector<xs__attributeGroup >attributeGroup;	/* optional element of type xs:attributeGroup */
	xs__anyAttribute *anyAttribute;	/* optional element of type xs:anyAttribute */
private:
	xs__schema *schemaRef;	/* not serialized */
	int level;	/* not serialized */
public:
	xs__complexType();	/* transient */
	int traverse(xs__schema &_param_36);	/* transient */
	void schemaPtr(xs__schema *_param_37);	/* transient */
	xs__schema *schemaPtr() const;	/* transient */
	int baseLevel();	/* transient */
public:
	virtual int soap_type() const { return 22; } /* = unique id SOAP_TYPE_xs__complexType */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	virtual ~xs__complexType() { }
};
#endif

#ifndef SOAP_TYPE_xs__import
#define SOAP_TYPE_xs__import (158)
/* xs:import */
class SOAP_CMAC xs__import
{
public:
	char *namespace_;	/* optional attribute */
	char *schemaLocation;	/* optional attribute */
private:
	xs__schema *schemaRef;	/* not serialized */
public:
	xs__import();	/* transient */
	int traverse(xs__schema &_param_38);	/* transient */
	void schemaPtr(xs__schema *_param_39);	/* transient */
	xs__schema *schemaPtr() const;	/* transient */
public:
	virtual int soap_type() const { return 158; } /* = unique id SOAP_TYPE_xs__import */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	virtual ~xs__import() { }
};
#endif

#ifndef SOAP_TYPE_xs__include
#define SOAP_TYPE_xs__include (163)
/* xs:include */
class SOAP_CMAC xs__include
{
public:
	char *schemaLocation;	/* optional attribute */
private:
	xs__schema *schemaRef;	/* not serialized */
public:
	xs__include();	/* transient */
	int preprocess(xs__schema &_param_40);	/* transient */
	int traverse(xs__schema &_param_41);	/* transient */
	void schemaPtr(xs__schema *_param_42);	/* transient */
	xs__schema *schemaPtr() const;	/* transient */
public:
	virtual int soap_type() const { return 163; } /* = unique id SOAP_TYPE_xs__include */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	virtual ~xs__include() { }
};
#endif

#ifndef SOAP_TYPE_xs__redefine
#define SOAP_TYPE_xs__redefine (169)
/* xs:redefine */
class SOAP_CMAC xs__redefine
{
public:
	char *schemaLocation;	/* optional attribute */
	std::vector<xs__group >group;	/* optional element of type xs:group */
	std::vector<xs__attributeGroup >attributeGroup;	/* optional element of type xs:attributeGroup */
	std::vector<xs__simpleType >simpleType;	/* optional element of type xs:simpleType */
	std::vector<xs__complexType >complexType;	/* optional element of type xs:complexType */
private:
	xs__schema *schemaRef;	/* not serialized */
public:
	xs__redefine();	/* transient */
	int preprocess(xs__schema &_param_43);	/* transient */
	int traverse(xs__schema &_param_44);	/* transient */
	void schemaPtr(xs__schema *_param_45);	/* transient */
	xs__schema *schemaPtr() const;	/* transient */
public:
	virtual int soap_type() const { return 169; } /* = unique id SOAP_TYPE_xs__redefine */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	virtual ~xs__redefine() { }
};
#endif



#ifndef SOAP_TYPE_xs__schema
#define SOAP_TYPE_xs__schema (20)
/* xs:schema */
class SOAP_CMAC xs__schema
{
public:
	char *targetNamespace;	/* optional attribute */
	char *version;	/* optional attribute */
	enum xs__formChoice attributeFormDefault;	/* optional attribute */
	enum xs__formChoice elementFormDefault;	/* optional attribute */
	std::vector<xs__include >include;	/* optional element of type xs:include */
	std::vector<xs__redefine >redefine;	/* optional element of type xs:redefine */
	std::vector<xs__import >import;	/* optional element of type xs:import */
	std::vector<xs__attribute >attribute;	/* optional element of type xs:attribute */
	std::vector<xs__element >element;	/* optional element of type xs:element */
	std::vector<xs__group >group;	/* optional element of type xs:group */
	std::vector<xs__attributeGroup >attributeGroup;	/* optional element of type xs:attributeGroup */
	std::vector<xs__simpleType >simpleType;	/* optional element of type xs:simpleType */
	std::vector<xs__complexType >complexType;	/* optional element of type xs:complexType */
	struct soap *soap;	/* transient */
private:
	bool updated;	/* not serialized */
	char *location;	/* not serialized */
	int redirs;	/* not serialized */
	SetOfString builtinTypeSet;	/* transient */	/* not serialized */
	SetOfString builtinElementSet;	/* transient */	/* not serialized */
	SetOfString builtinAttributeSet;	/* transient */	/* not serialized */
public:
	xs__schema();	/* transient */
	xs__schema(struct soap *_param_46);	/* transient */
	xs__schema(struct soap *_param_47, const char *_param_48, const char *_param_49);	/* transient */
	virtual ~xs__schema();	/* transient */
	int get(struct soap *_param_50);	/* transient */
	int preprocess();	/* transient */
	int insert(xs__schema &_param_51);	/* transient */
	int traverse();	/* transient */
	int read(const char *_param_52, const char *_param_53);	/* transient */
	void sourceLocation(const char *_param_54);	/* transient */
	const char *sourceLocation();	/* transient */
	int error();	/* transient */
	void print_fault();	/* transient */
	void builtinType(const char *_param_55);	/* transient */
	void builtinElement(const char *_param_56);	/* transient */
	void builtinAttribute(const char *_param_57);	/* transient */
	const SetOfString &builtinTypes() const;	/* transient */	/* not serialized */
	const SetOfString &builtinElements() const;	/* transient */	/* not serialized */
	const SetOfString &builtinAttributes() const;	/* transient */	/* not serialized */
	friend ostream &operator<<(ostream &_param_58, const xs__schema &_param_59);	/* transient */
	friend istream &operator>>(istream &_param_60, xs__schema &_param_61);	/* transient */
public:
	virtual int soap_type() const { return 20; } /* = unique id SOAP_TYPE_xs__schema */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
};
#endif

#ifndef SOAP_TYPE_soap__binding
#define SOAP_TYPE_soap__binding (218)
/* soap:binding */
class SOAP_CMAC soap__binding
{
public:
	char *transport;	/* optional attribute */
	enum soap__styleChoice *style;	/* optional attribute */
public:
	virtual int soap_type() const { return 218; } /* = unique id SOAP_TYPE_soap__binding */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	         soap__binding() : transport(NULL), style(NULL) { }
	virtual ~soap__binding() { }
};
#endif

#ifndef SOAP_TYPE_soap__operation
#define SOAP_TYPE_soap__operation (220)
/* soap:operation */
class SOAP_CMAC soap__operation
{
public:
	char *soapAction;	/* optional attribute */
	enum soap__styleChoice *style;	/* optional attribute */
public:
	virtual int soap_type() const { return 220; } /* = unique id SOAP_TYPE_soap__operation */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	         soap__operation() : soapAction(NULL), style(NULL) { }
	virtual ~soap__operation() { }
};
#endif

#ifndef SOAP_TYPE_soap__body
#define SOAP_TYPE_soap__body (222)
/* soap:body */
class SOAP_CMAC soap__body
{
public:
	char *encodingStyle;	/* optional attribute */
	char *parts;	/* optional attribute */
	enum soap__useChoice use;	/* optional attribute */
	char *namespace_;	/* optional attribute */
public:
	virtual int soap_type() const { return 222; } /* = unique id SOAP_TYPE_soap__body */
	virtual void soap_default(struct soap*);
	virtual void soap_serialize(struct soap*) const;
	virtual int soap_put(struct soap*, const char*, const char*) const;
	virtual int soap_out(struct soap*, const char*, int, const char*) const;
	virtual void *soap_get(struct soap*, const char*, const char*);
	virtual void *soap_in(struct soap*, const char*, const char*);
	         soap__body() : encodingStyle(NULL), parts(NULL), use((enum soap__useChoice)0), namespace_(NULL) { }
	virtual ~soap__body() { }
};
#endif

#ifndef SOAP_TYPE_soap__fault
#define SOAP_TYPE_soap__fault (223)
/* soap:fault */
class SOAP_CMAC soap__fault
{
public:
	char *name;	/* optional attribute */
	char *encodingStyle;	/* optional attribute */