Main Page   Class Hierarchy   Compound List   File List   Compound Members   File Members   Examples  

Call.h

Go to the documentation of this file.
00001 /*
00002  *   Copyright 2003-2004 The Apache Software Foundation.
00003  *
00004  *   Licensed under the Apache License, Version 2.0 (the "License");
00005  *   you may not use this file except in compliance with the License.
00006  *   You may obtain a copy of the License at
00007  *
00008  *       http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  *   Unless required by applicable law or agreed to in writing, software
00011  *   distributed under the License is distributed on an "AS IS" BASIS,
00012  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  *   See the License for the specific language governing permissions and
00014  *   limitations under the License.
00015  *
00016  */
00017 
00030 /*
00031  * Revision 1.1  2004/05/24 samisa
00032  * Added accesser to transport 
00033  */
00034  
00035 /*
00036  * Revision 1.2  2004/05/25 samisa
00037  * Added accesser to SOAP serializer 
00038  */
00039 
00040 /*
00041  * Revision 1.3  2004/05/31 samisa
00042  * Added setProxy
00043  */
00044 
00045 /* Call.h: interface for the Call class.*/
00046 
00047 
00048 #if !defined(_CALL_H____OF_AXIS_INCLUDED_)
00049 #define _CALL_H____OF_AXIS_INCLUDED_
00050 
00051 #include "../server/GDefine.h"
00052 #include "../server/Packet.h"
00053 
00054 #include "../server/TypeMapping.h"
00055 #include "../server/AxisUserAPI.h"
00056 #include "../server/SoapEnvVersions.h"
00057 #include "../server/WSDDDefines.h"
00058 #include "../server/IHeaderBlock.h"
00059 
00060 #ifdef __cplusplus
00061 #include "../server/ISoapHeader.h"
00062 
00063 AXIS_CPP_NAMESPACE_START
00064 
00065 class ClientAxisEngine;
00066 class SOAPTransport;
00067 class MessageData;
00068 class SoapDeSerializer;
00069 class SoapSerializer;
00070 
00071 AXIS_CPP_NAMESPACE_END
00072 
00073 #else
00074 #endif
00075 
00076 AXIS_CPP_NAMESPACE_USE
00077 
00078 typedef struct {
00079     void (AXISCALL* setSOAPVersion)(void* pObj, SOAP_VERSION version);
00080     int (AXISCALL* setTransportProperty)(void* pObj,
00081         AXIS_TRANSPORT_INFORMATION_TYPE type, const char* value);
00082     int (AXISCALL* setProtocol)(void* pObj, AXIS_PROTOCOL_TYPE protocol);
00083     int (AXISCALL* initialize)(void* pObj, PROVIDERTYPE nStyle, int secure);
00084     int (AXISCALL* invoke)(void* pObj);
00085     int (AXISCALL* unInitialize)(void* pObj);
00086 
00087     /* Method that set the remote method name */
00088     void (AXISCALL* setOperation)(void* pObj, const char* pchOperation,
00089         const char* pchNamespace);
00090     int (AXISCALL* setEndpointURI)(void* pObj, const char* pchEndpointURI);
00091 
00092     /* Method for adding complex parameters */
00093     void (AXISCALL* addCmplxParameter)(void* pObj, void* pObject,
00094         void* pSZFunct, void* pDelFunct, const AxisChar* pName,
00095         const AxisChar* pNamespace);
00096     /* Method for adding complex type array parameters */
00097     void (AXISCALL* addCmplxArrayParameter)(void* pObj, Axis_Array* pArray,
00098         void* pSZFunct, void* pDelFunct, void* pSizeFunct,
00099         const AxisChar* pName, const AxisChar* pNamespace);
00100     /* Method for adding basic type array parameters */
00101     void (AXISCALL* addBasicArrayParameter)(void* pObj, Axis_Array* pArray,
00102         XSDTYPE nType, const char* pName);
00103     /* Method for adding parameters of basic types */
00104     void (AXISCALL* addParameter)(void* pObj, void* pValue,const char* pName,
00105         XSDTYPE nType);
00106 
00107     /* Methods used by stubs to get a deserialized value of an XML element
00108      * as basic types
00109      */
00110     int (AXISCALL* getElementAsInt)(void* pObj, const AxisChar* pName,
00111         const AxisChar* pNamespace);
00112     xsd__boolean (AXISCALL* getElementAsBoolean)(void* pObj,
00113         const AxisChar* pName, const AxisChar* pNamespace);
00114     unsigned int (AXISCALL* getElementAsUnsignedInt)(void* pObj,
00115         const AxisChar* pName, const AxisChar* pNamespace);
00116     short (AXISCALL* getElementAsShort)(void* pObj, const AxisChar* pName,
00117         const AxisChar* pNamespace);
00118     unsigned short (AXISCALL* getElementAsUnsignedShort)(void* pObj,
00119         const AxisChar* pName, const AxisChar* pNamespace);
00120     char (AXISCALL* getElementAsByte)(void* pObj, const AxisChar* pName,
00121         const AxisChar* pNamespace);
00122     unsigned char (AXISCALL* getElementAsUnsignedByte)(void* pObj,
00123         const AxisChar* pName, const AxisChar* pNamespace);
00124     long (AXISCALL* getElementAsLong)(void* pObj, const AxisChar* pName,
00125         const AxisChar* pNamespace);
00126     long (AXISCALL* getElementAsInteger)(void* pObj, const AxisChar* pName,
00127         const AxisChar* pNamespace);
00128     unsigned long (AXISCALL* getElementAsUnsignedLong)(void* pObj,
00129         const AxisChar* pName, const AxisChar* pNamespace);
00130     float (AXISCALL* getElementAsFloat)(void* pObj, const AxisChar* pName,
00131         const AxisChar* pNamespace);
00132     double (AXISCALL* getElementAsDouble)(void* pObj, const AxisChar* pName,
00133         const AxisChar* pNamespace);
00134     double (AXISCALL* getElementAsDecimal)(void* pObj, const AxisChar* pName,
00135         const AxisChar* pNamespace);
00136     AxisChar* (AXISCALL* getElementAsString)(void* pObj, const AxisChar* pName,
00137         const AxisChar* pNamespace);
00138     AxisChar* (AXISCALL* getElementAsAnyURI)(void* pObj, const AxisChar* pName,
00139         const AxisChar* pNamespace);
00140     AxisChar* (AXISCALL* getElementAsQName)(void* pObj, const AxisChar* pName,
00141         const AxisChar* pNamespace);
00142     xsd__hexBinary (AXISCALL* getElementAsHexBinary)(void* pObj,
00143         const AxisChar* pName, const AxisChar* pNamespace);
00144     xsd__base64Binary (AXISCALL* getElementAsBase64Binary)(void* pObj,
00145         const AxisChar* pName, const AxisChar* pNamespace);
00146     struct tm (AXISCALL* getElementAsDateTime)(void* pObj,
00147         const AxisChar* pName, const AxisChar* pNamespace);
00148     struct tm (AXISCALL* getElementAsDate)(void* pObj, const AxisChar* pName,
00149         const AxisChar* pNamespace);
00150     struct tm (AXISCALL* getElementAsTime)(void* pObj, const AxisChar* pName,
00151         const AxisChar* pNamespace);
00152     long (AXISCALL* getElementAsDuration)(void* pObj, const AxisChar* pName,
00153         const AxisChar* pNamespace);
00154 
00155     /* Methods used by stubs to get a deserialized value of an XML attribute
00156      * basic types
00157      */
00158     int (AXISCALL* getAttributeAsInt)(void* pObj, const AxisChar* pName,
00159         const AxisChar* pNamespace);
00160     xsd__boolean (AXISCALL* getAttributeAsBoolean)(void* pObj,
00161         const AxisChar* pName, const AxisChar* pNamespace);
00162     unsigned int (AXISCALL* getAttributeAsUnsignedInt)(void* pObj,
00163         const AxisChar* pName, const AxisChar* pNamespace);
00164     short (AXISCALL* getAttributeAsShort)(void* pObj, const AxisChar* pName,
00165         const AxisChar* pNamespace);
00166     unsigned short (AXISCALL* getAttributeAsUnsignedShort)(void* pObj,
00167         const AxisChar* pName, const AxisChar* pNamespace);
00168     char (AXISCALL* getAttributeAsByte)(void* pObj, const AxisChar* pName,
00169         const AxisChar* pNamespace);
00170     unsigned char (AXISCALL* getAttributeAsUnsignedByte)(void* pObj,
00171         const AxisChar* pName, const AxisChar* pNamespace);
00172     long (AXISCALL* getAttributeAsLong)(void* pObj, const AxisChar* pName,
00173         const AxisChar* pNamespace);
00174     long (AXISCALL* getAttributeAsInteger)(void* pObj, const AxisChar* pName,
00175         const AxisChar* pNamespace);
00176     unsigned long (AXISCALL* getAttributeAsUnsignedLong)(void* pObj,
00177         const AxisChar* pName, const AxisChar* pNamespace);
00178     float (AXISCALL* getAttributeAsFloat)(void* pObj, const AxisChar* pName,
00179         const AxisChar* pNamespace);
00180     double (AXISCALL* getAttributeAsDouble)(void* pObj, const AxisChar* pName,
00181         const AxisChar* pNamespace);
00182     double (AXISCALL* getAttributeAsDecimal)(void* pObj, const AxisChar* pName,
00183         const AxisChar* pNamespace);
00184     AxisChar* (AXISCALL* getAttributeAsString)(void* pObj,
00185         const AxisChar* pName, const AxisChar* pNamespace);
00186     AxisChar* (AXISCALL* getAttributeAsAnyURI)(void* pObj,
00187         const AxisChar* pName, const AxisChar* pNamespace);
00188     AxisChar* (AXISCALL* getAttributeAsQName)(void* pObj,
00189         const AxisChar* pName, const AxisChar* pNamespace);
00190     xsd__hexBinary (AXISCALL* getAttributeAsHexBinary)(void* pObj,
00191         const AxisChar* pName, const AxisChar* pNamespace);
00192     xsd__base64Binary (AXISCALL* getAttributeAsBase64Binary)(void* pObj,
00193         const AxisChar* pName, const AxisChar* pNamespace);
00194     struct tm (AXISCALL* getAttributeAsDateTime)(void* pObj,
00195         const AxisChar* pName, const AxisChar* pNamespace);
00196     struct tm (AXISCALL* getAttributeAsDate)(void* pObj, const AxisChar* pName,
00197         const AxisChar* pNamespace);
00198     struct tm (AXISCALL* getAttributeAsTime)(void* pObj, const AxisChar* pName,
00199         const AxisChar* pNamespace);
00200     long (AXISCALL* getAttributeAsDuration)(void* pObj, const AxisChar* pName,
00201         const AxisChar* pNamespace);
00202 
00203     /* Method used by stubs to get a deserialized value of complex types */
00204     void* (AXISCALL* getCmplxObject)(void* pObj, void* pDZFunct,
00205         void* pCreFunct, void* pDelFunct, const AxisChar* pName,
00206         const AxisChar* pNamespace);
00207     /* Method used by stubs to get a deserialized Array of complex types */
00208     Axis_Array (AXISCALL* getCmplxArray)(void* pObj, void* pDZFunct,
00209         void* pCreFunct, void* pDelFunct, void* pSizeFunct,
00210         const AxisChar* pName, const AxisChar* pNamespace);
00211     /* Method used by stubs to get a deserialized Array of basic types */
00212     Axis_Array (AXISCALL* getBasicArray)(void* pObj, XSDTYPE nType,
00213         const AxisChar* pName, const AxisChar* pNamespace);
00214 
00215     int (AXISCALL* checkMessage)(void *pObj, const AxisChar* pName,
00216         const AxisChar* pNamespace);
00217 
00218     void* (AXISCALL* checkFault)(void *pObj, const AxisChar* pName,
00219         const AxisChar* pNamespace);
00220 
00221     /* Minimal error check */
00222     int (AXISCALL* getStatus)(void *pObj);
00223 
00224     AnyType* (AXISCALL* getAnyObject)(void *pObj);
00225 
00226     int (AXISCALL* addAnyObject)(void *pObj, AnyType* pAnyObject);
00227 
00228     const AxisChar* (AXISCALL* getNamespacePrefix)(void *pObj,
00229         const AxisChar* pNamespace);
00230 
00231     HeaderBlock_C (AXISCALL* createHeaderBlock)(void *pObj,
00232         AxisChar *pachLocalName, AxisChar *pachUri);
00233 
00234 } CallFunctions;
00235 
00236 #ifdef __cplusplus
00237 AXIS_CPP_NAMESPACE_START
00238 class STORAGE_CLASS_INFO CallBase
00239 {
00240 public:
00241     virtual void AXISCALL setSOAPVersion(SOAP_VERSION version)=0;
00242     virtual int AXISCALL setTransportProperty(AXIS_TRANSPORT_INFORMATION_TYPE
00243         type, const char* value)=0;
00244     virtual int AXISCALL setProtocol(AXIS_PROTOCOL_TYPE protocol)=0;
00245     virtual int AXISCALL initialize(PROVIDERTYPE nStyle, int secure)=0;
00246     virtual int AXISCALL invoke()=0;
00247     virtual int AXISCALL unInitialize()=0;
00248 
00249     /* Method that set the remote method name */
00250     virtual void AXISCALL setOperation(const char* pchOperation,
00251         const char* pchNamespace)=0;
00252     virtual int AXISCALL setEndpointURI(const char* pchEndpointURI)=0;
00253 
00254     /* Method for adding complex parameters */
00255     virtual void AXISCALL addCmplxParameter(void* pObject, void* pSZFunct,
00256         void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace)=0;
00257     /* Method for adding complex type array parameters */
00258     virtual void AXISCALL addCmplxArrayParameter(Axis_Array* pArray,
00259         void* pSZFunct, void* pDelFunct, void* pSizeFunct,
00260         const AxisChar* pName, const AxisChar* pNamespace)=0;
00261     /* Method for adding basic type array parameters */
00262     virtual void AXISCALL addBasicArrayParameter(Axis_Array* pArray,
00263         XSDTYPE nType, const char* pName)=0;
00264     /* Method for adding parameters of basic types */
00265     virtual void AXISCALL addParameter(void* pValue,const char* pName,
00266         XSDTYPE nType)=0;
00267 
00268     /* Methods used by stubs to get a deserialized value of an XML element
00269      * as basic types
00270      */
00271     virtual int AXISCALL getElementAsInt(const AxisChar* pName,
00272         const AxisChar* pNamespace)=0;
00273     virtual xsd__boolean AXISCALL getElementAsBoolean(const AxisChar* pName,
00274         const AxisChar* pNamespace)=0;
00275     virtual unsigned int AXISCALL getElementAsUnsignedInt(const AxisChar*
00276         pName, const AxisChar* pNamespace)=0;
00277     virtual short AXISCALL getElementAsShort(const AxisChar* pName,
00278         const AxisChar* pNamespace)=0;
00279     virtual unsigned short AXISCALL getElementAsUnsignedShort(const AxisChar*
00280         pName, const AxisChar* pNamespace)=0;
00281     virtual char AXISCALL getElementAsByte(const AxisChar* pName,
00282         const AxisChar* pNamespace)=0;
00283     virtual unsigned char AXISCALL getElementAsUnsignedByte(const AxisChar*
00284         pName, const AxisChar* pNamespace)=0;
00285     virtual long AXISCALL getElementAsLong(const AxisChar* pName,
00286         const AxisChar* pNamespace)=0;
00287     virtual long AXISCALL getElementAsInteger(const AxisChar* pName,
00288         const AxisChar* pNamespace)=0;
00289     virtual unsigned long AXISCALL getElementAsUnsignedLong(const AxisChar*
00290         pName, const AxisChar* pNamespace)=0;
00291     virtual float AXISCALL getElementAsFloat(const AxisChar* pName,
00292         const AxisChar* pNamespace)=0;
00293     virtual double AXISCALL getElementAsDouble(const AxisChar* pName,
00294         const AxisChar* pNamespace)=0;
00295     virtual double AXISCALL getElementAsDecimal(const AxisChar* pName,
00296         const AxisChar* pNamespace)=0;
00297     virtual AxisChar* AXISCALL getElementAsString(const AxisChar* pName,
00298         const AxisChar* pNamespace)=0;
00299     virtual AxisChar* AXISCALL getElementAsAnyURI(const AxisChar* pName,
00300         const AxisChar* pNamespace)=0;
00301     virtual AxisChar* AXISCALL getElementAsQName(const AxisChar* pName,
00302         const AxisChar* pNamespace)=0;
00303     virtual xsd__hexBinary AXISCALL getElementAsHexBinary(const AxisChar*
00304         pName, const AxisChar* pNamespace)=0;
00305     virtual xsd__base64Binary AXISCALL getElementAsBase64Binary(const
00306         AxisChar* pName, const AxisChar* pNamespace)=0;
00307     virtual struct tm AXISCALL getElementAsDateTime(const AxisChar* pName,
00308         const AxisChar* pNamespace)=0;
00309     virtual struct tm AXISCALL getElementAsDate(const AxisChar* pName,
00310         const AxisChar* pNamespace)=0;
00311     virtual struct tm AXISCALL getElementAsTime(const AxisChar* pName,
00312         const AxisChar* pNamespace)=0;
00313     virtual long AXISCALL getElementAsDuration(const AxisChar* pName,
00314         const AxisChar* pNamespace)=0;
00315 
00316     /* Methods used by stubs to get a deserialized value of XML attribute
00317      * as basic types
00318      */
00319     virtual int AXISCALL getAttributeAsInt(const AxisChar* pName,
00320         const AxisChar* pNamespace)=0;
00321     virtual xsd__boolean AXISCALL getAttributeAsBoolean(const AxisChar* pName,
00322         const AxisChar* pNamespace)=0;
00323     virtual unsigned int AXISCALL getAttributeAsUnsignedInt(const AxisChar*
00324         pName, const AxisChar* pNamespace)=0;
00325     virtual short AXISCALL getAttributeAsShort(const AxisChar* pName,
00326         const AxisChar* pNamespace)=0;
00327     virtual unsigned short AXISCALL getAttributeAsUnsignedShort(const
00328         AxisChar* pName, const AxisChar* pNamespace)=0;
00329     virtual char AXISCALL getAttributeAsByte(const AxisChar* pName,
00330         const AxisChar* pNamespace)=0;
00331     virtual unsigned char AXISCALL getAttributeAsUnsignedByte(const AxisChar*
00332         pName, const AxisChar* pNamespace)=0;
00333     virtual long AXISCALL getAttributeAsLong(const AxisChar* pName,
00334         const AxisChar* pNamespace)=0;
00335     virtual long AXISCALL getAttributeAsInteger(const AxisChar* pName,
00336         const AxisChar* pNamespace)=0;
00337     virtual unsigned long AXISCALL getAttributeAsUnsignedLong(const AxisChar*
00338         pName, const AxisChar* pNamespace)=0;
00339     virtual float AXISCALL getAttributeAsFloat(const AxisChar* pName,
00340         const AxisChar* pNamespace)=0;
00341     virtual double AXISCALL getAttributeAsDouble(const AxisChar* pName,
00342         const AxisChar* pNamespace)=0;
00343     virtual double AXISCALL getAttributeAsDecimal(const AxisChar* pName,
00344         const AxisChar* pNamespace)=0;
00345     virtual AxisChar* AXISCALL getAttributeAsString(const AxisChar* pName,
00346         const AxisChar* pNamespace)=0;
00347     virtual AxisChar* AXISCALL getAttributeAsAnyURI(const AxisChar* pName,
00348         const AxisChar* pNamespace)=0;
00349     virtual AxisChar* AXISCALL getAttributeAsQName(const AxisChar* pName,
00350         const AxisChar* pNamespace)=0;
00351     virtual xsd__hexBinary AXISCALL getAttributeAsHexBinary(const AxisChar*
00352         pName, const AxisChar* pNamespace)=0;
00353     virtual xsd__base64Binary AXISCALL getAttributeAsBase64Binary(const
00354         AxisChar* pName, const AxisChar* pNamespace)=0;
00355     virtual struct tm AXISCALL getAttributeAsDateTime(const AxisChar* pName,
00356         const AxisChar* pNamespace)=0;
00357     virtual struct tm AXISCALL getAttributeAsDate(const AxisChar* pName,
00358         const AxisChar* pNamespace)=0;
00359     virtual struct tm AXISCALL getAttributeAsTime(const AxisChar* pName,
00360         const AxisChar* pNamespace)=0;
00361     virtual long AXISCALL getAttributeAsDuration(const AxisChar* pName,
00362         const AxisChar* pNamespace)=0;
00363 
00364     /* Method used by stubs to get a deserialized value of complex types */
00365     virtual void* AXISCALL getCmplxObject(void* pDZFunct, void* pCreFunct,
00366         void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace)=0;
00367     /* Method used by stubs to get a deserialized Array of complex types */
00368     virtual Axis_Array AXISCALL getCmplxArray(void* pDZFunct, void* pCreFunct,
00369         void* pDelFunct, void* pSizeFunct, const AxisChar* pName,
00370         const AxisChar* pNamespace)=0;
00371     /* Method used by stubs to get a deserialized Array of basic types */
00372     virtual Axis_Array AXISCALL getBasicArray(XSDTYPE nType,
00373         const AxisChar* pName, const AxisChar* pNamespace)=0;
00374 
00375     virtual int AXISCALL checkMessage(const AxisChar* pName,
00376         const AxisChar* pNamespace)=0;
00377 
00378     virtual void* AXISCALL checkFault(const AxisChar* pName,
00379         const AxisChar* pNamespace)=0;
00380 
00381     /* Minimal error check */
00382     virtual int AXISCALL getStatus()=0;
00383 
00384     virtual AnyType* AXISCALL getAnyObject()=0;
00385     virtual int AXISCALL addAnyObject(AnyType* pAnyObject)=0;
00386     virtual const AxisChar* AXISCALL getNamespacePrefix
00387         (const AxisChar* pNamespace)=0;
00388 
00389     virtual IHeaderBlock* AXISCALL createHeaderBlock(AxisChar *pachLocalName,
00390         AxisChar *pachUri)=0;
00391 
00392     /* following stuff is needed to provide the interface for C web services */
00393 public:
00394     static CallFunctions ms_VFtable;
00395     static bool bInitialized;
00396     /* add static functions for all interface functions here */
00397     static void AXISCALL s_SetSOAPVersion(void* pObj, SOAP_VERSION version)
00398     {((CallBase*)pObj)->setSOAPVersion(version);};
00399     static int AXISCALL s_SetTransportProperty(void* pObj,
00400         AXIS_TRANSPORT_INFORMATION_TYPE type, const char* value)
00401     { return ((CallBase*)pObj)->setTransportProperty(type,value);};
00402     static int AXISCALL s_SetProtocol(void* pObj, AXIS_PROTOCOL_TYPE protocol)
00403     { return ((CallBase*)pObj)->setProtocol(protocol);};
00404     static int AXISCALL s_InitializeCall(void* pObj, PROVIDERTYPE nStyle,
00405         int secure)
00406     { return ((CallBase*)pObj)->initialize(nStyle, secure);};
00407     static int AXISCALL s_Invoke(void* pObj)
00408     { return ((CallBase*)pObj)->invoke();};
00409     static int AXISCALL s_UnInitialize(void* pObj)
00410     { return ((CallBase*)pObj)->unInitialize();};
00411 
00412     /* Method that set the remote method name */
00413     static void AXISCALL s_SetOperation(void* pObj, const char* pchOperation,
00414         const char* pchNamespace)
00415     { ((CallBase*)pObj)->setOperation(pchOperation, pchNamespace);};
00416     static int AXISCALL s_SetEndpointURI(void* pObj,
00417         const char* pchEndpointURI)
00418     { return ((CallBase*)pObj)->setEndpointURI(pchEndpointURI);};
00419 
00420     static void AXISCALL s_AddParameter(void* pObj, void* pValue,
00421         const AxisChar* pchName, XSDTYPE type)
00422     { ((CallBase*)pObj)->addParameter(pValue, pchName, type);};
00423     static void AXISCALL s_AddCmplxArrayParameter(void* pObj,
00424         Axis_Array* pArray, void* pSZFunct, void* pDelFunct, void* pSizeFunct,
00425         const AxisChar* pName, const AxisChar* pNamespace)
00426     { ((CallBase*)pObj)->addCmplxArrayParameter(pArray, pSZFunct, pDelFunct,
00427         pSizeFunct, pName, pNamespace);};
00428     static void AXISCALL s_AddBasicArrayParameter(void* pObj,
00429         Axis_Array* pArray, XSDTYPE nType, const AxisChar* pName)
00430     { ((CallBase*)pObj)->addBasicArrayParameter(pArray, nType, pName);};
00431     static void AXISCALL s_AddCmplxParameter(void* pObj, void* pObject,
00432         void* pDZFunct, void* pDelFunct, const AxisChar* pName,
00433         const AxisChar* pNamespace)
00434     { ((CallBase*)pObj)->addCmplxParameter(pObject, pDZFunct, pDelFunct, pName,
00435         pNamespace);};
00436 
00437     static int AXISCALL s_GetElementAsInt(void* pObj, const AxisChar* pName,
00438         const AxisChar* pNamespace)
00439     { return ((CallBase*)pObj)->getElementAsInt(pName, pNamespace);};
00440     static xsd__boolean AXISCALL s_GetElementAsBoolean(void* pObj,
00441         const AxisChar* pName, const AxisChar* pNamespace)
00442     { return ((CallBase*)pObj)->getElementAsBoolean(pName, pNamespace);};
00443     static unsigned int AXISCALL s_GetElementAsUnsignedInt(void* pObj,
00444         const AxisChar* pName, const AxisChar* pNamespace)
00445     { return ((CallBase*)pObj)->getElementAsUnsignedInt(pName, pNamespace);};
00446     static short AXISCALL s_GetElementAsShort(void* pObj,
00447         const AxisChar* pName, const AxisChar* pNamespace)
00448     { return ((CallBase*)pObj)->getElementAsShort(pName, pNamespace);};
00449     static unsigned short AXISCALL s_GetElementAsUnsignedShort(void* pObj,
00450         const AxisChar* pName, const AxisChar* pNamespace)
00451     { return ((CallBase*)pObj)->getElementAsUnsignedShort(pName, pNamespace);};
00452     static char AXISCALL s_GetElementAsByte(void* pObj, const AxisChar* pName,
00453         const AxisChar* pNamespace)
00454     { return ((CallBase*)pObj)->getElementAsByte(pName, pNamespace);};
00455     static unsigned char AXISCALL s_GetElementAsUnsignedByte(void* pObj,
00456         const AxisChar* pName, const AxisChar* pNamespace)
00457     { return ((CallBase*)pObj)->getElementAsUnsignedByte(pName, pNamespace);};
00458     static long AXISCALL s_GetElementAsLong(void* pObj, const AxisChar* pName,
00459         const AxisChar* pNamespace)
00460     { return ((CallBase*)pObj)->getElementAsLong(pName, pNamespace);};
00461     static long AXISCALL s_GetElementAsInteger(void* pObj,
00462         const AxisChar* pName, const AxisChar* pNamespace)
00463     { return ((CallBase*)pObj)->getElementAsInteger(pName, pNamespace);};
00464     static unsigned long AXISCALL s_GetElementAsUnsignedLong(void* pObj,
00465         const AxisChar* pName, const AxisChar* pNamespace)
00466     { return ((CallBase*)pObj)->getElementAsUnsignedLong(pName, pNamespace);};
00467     static float AXISCALL s_GetElementAsFloat(void* pObj,
00468         const AxisChar* pName, const AxisChar* pNamespace)
00469     { return ((CallBase*)pObj)->getElementAsFloat(pName, pNamespace);};
00470     static double AXISCALL s_GetElementAsDouble(void* pObj,
00471         const AxisChar* pName, const AxisChar* pNamespace)
00472     { return ((CallBase*)pObj)->getElementAsDouble(pName, pNamespace);};
00473     static double AXISCALL s_GetElementAsDecimal(void* pObj,
00474         const AxisChar* pName, const AxisChar* pNamespace)
00475     { return ((CallBase*)pObj)->getElementAsDouble(pName, pNamespace);};
00476     static AxisChar* AXISCALL s_GetElementAsString(void* pObj,
00477         const AxisChar* pName, const AxisChar* pNamespace)
00478     { return ((CallBase*)pObj)->getElementAsString(pName, pNamespace);};
00479     static AxisChar* AXISCALL s_GetElementAsAnyURI(void* pObj,
00480         const AxisChar* pName, const AxisChar* pNamespace)
00481     { return ((CallBase*)pObj)->getElementAsAnyURI(pName, pNamespace);};
00482     static AxisChar* AXISCALL s_GetElementAsQName(void* pObj,
00483         const AxisChar* pName, const AxisChar* pNamespace)
00484     { return ((CallBase*)pObj)->getElementAsQName(pName, pNamespace);};
00485     static xsd__hexBinary AXISCALL s_GetElementAsHexBinary(void* pObj,
00486         const AxisChar* pName, const AxisChar* pNamespace)
00487     { return ((CallBase*)pObj)->getElementAsHexBinary(pName, pNamespace);};
00488     static xsd__base64Binary AXISCALL s_GetElementAsBase64Binary(void* pObj,
00489         const AxisChar* pName, const AxisChar* pNamespace)
00490     { return ((CallBase*)pObj)->getElementAsBase64Binary(pName, pNamespace);};
00491     static struct tm AXISCALL s_GetElementAsDateTime(void* pObj,
00492         const AxisChar* pName, const AxisChar* pNamespace)
00493     { return ((CallBase*)pObj)->getElementAsDateTime(pName, pNamespace);};
00494     static struct tm AXISCALL s_GetElementAsDate(void* pObj,
00495         const AxisChar* pName, const AxisChar* pNamespace)
00496     { return ((CallBase*)pObj)->getElementAsDate(pName, pNamespace);};
00497     static struct tm AXISCALL s_GetElementAsTime(void* pObj,
00498         const AxisChar* pName, const AxisChar* pNamespace)
00499     { return ((CallBase*)pObj)->getElementAsTime(pName, pNamespace);};
00500     static long AXISCALL s_GetElementAsDuration(void* pObj,
00501         const AxisChar* pName, const AxisChar* pNamespace)
00502     { return ((CallBase*)pObj)->getElementAsDuration(pName, pNamespace);};
00503 
00504     static int AXISCALL s_GetAttributeAsInt(void* pObj, const AxisChar* pName,
00505         const AxisChar* pNamespace)
00506     { return ((CallBase*)pObj)->getAttributeAsInt(pName, pNamespace);};
00507     static xsd__boolean AXISCALL s_GetAttributeAsBoolean(void* pObj,
00508         const AxisChar* pName, const AxisChar* pNamespace)
00509     { return ((CallBase*)pObj)->getAttributeAsBoolean(pName, pNamespace);};
00510     static unsigned int AXISCALL s_GetAttributeAsUnsignedInt(void* pObj,
00511         const AxisChar* pName, const AxisChar* pNamespace)
00512     { return ((CallBase*)pObj)->getAttributeAsUnsignedInt(pName, pNamespace);};
00513     static short AXISCALL s_GetAttributeAsShort(void* pObj,
00514         const AxisChar* pName, const AxisChar* pNamespace)
00515     { return ((CallBase*)pObj)->getAttributeAsShort(pName, pNamespace);};
00516     static unsigned short AXISCALL s_GetAttributeAsUnsignedShort(void* pObj,
00517         const AxisChar* pName, const AxisChar* pNamespace)
00518     { return ((CallBase*)pObj)->getAttributeAsUnsignedShort(pName,
00519         pNamespace);};
00520     static char AXISCALL s_GetAttributeAsByte(void* pObj,
00521         const AxisChar* pName, const AxisChar* pNamespace)
00522     { return ((CallBase*)pObj)->getAttributeAsByte(pName, pNamespace);};
00523     static unsigned char AXISCALL s_GetAttributeAsUnsignedByte(void* pObj,
00524         const AxisChar* pName, const AxisChar* pNamespace)
00525     { return ((CallBase*)pObj)->getAttributeAsUnsignedByte(pName,
00526         pNamespace);};
00527     static long AXISCALL s_GetAttributeAsLong(void* pObj,
00528         const AxisChar* pName, const AxisChar* pNamespace)
00529     { return ((CallBase*)pObj)->getAttributeAsLong(pName, pNamespace);};
00530     static long AXISCALL s_GetAttributeAsInteger(void* pObj,
00531         const AxisChar* pName, const AxisChar* pNamespace)
00532     { return ((CallBase*)pObj)->getAttributeAsInteger(pName, pNamespace);};
00533     static unsigned long AXISCALL s_GetAttributeAsUnsignedLong(void* pObj,
00534         const AxisChar* pName, const AxisChar* pNamespace)
00535     { return ((CallBase*)pObj)->getAttributeAsUnsignedLong(pName,
00536         pNamespace);};
00537     static float AXISCALL s_GetAttributeAsFloat(void* pObj,
00538         const AxisChar* pName, const AxisChar* pNamespace)
00539     { return ((CallBase*)pObj)->getAttributeAsFloat(pName, pNamespace);};
00540     static double AXISCALL s_GetAttributeAsDouble(void* pObj,
00541         const AxisChar* pName, const AxisChar* pNamespace)
00542     { return ((CallBase*)pObj)->getAttributeAsDouble(pName, pNamespace);};
00543     static double AXISCALL s_GetAttributeAsDecimal(void* pObj,
00544         const AxisChar* pName, const AxisChar* pNamespace)
00545     { return ((CallBase*)pObj)->getAttributeAsDecimal(pName, pNamespace);};
00546     static AxisChar* AXISCALL s_GetAttributeAsString(void* pObj,
00547         const AxisChar* pName, const AxisChar* pNamespace)
00548     { return ((CallBase*)pObj)->getAttributeAsString(pName, pNamespace);};
00549     static AxisChar* AXISCALL s_GetAttributeAsAnyURI(void* pObj,
00550         const AxisChar* pName, const AxisChar* pNamespace)
00551     { return ((CallBase*)pObj)->getAttributeAsAnyURI(pName, pNamespace);};
00552     static AxisChar* AXISCALL s_GetAttributeAsQName(void* pObj,
00553         const AxisChar* pName, const AxisChar* pNamespace)
00554     { return ((CallBase*)pObj)->getAttributeAsQName(pName, pNamespace);};
00555     static xsd__hexBinary AXISCALL s_GetAttributeAsHexBinary(void* pObj,
00556         const AxisChar* pName, const AxisChar* pNamespace)
00557     { return ((CallBase*)pObj)->getAttributeAsHexBinary(pName, pNamespace);};
00558     static xsd__base64Binary AXISCALL s_GetAttributeAsBase64Binary(void* pObj,
00559         const AxisChar* pName, const AxisChar* pNamespace)
00560     { return ((CallBase*)pObj)->getAttributeAsBase64Binary(pName,
00561         pNamespace);};
00562     static struct tm AXISCALL s_GetAttributeAsDateTime(void* pObj,
00563         const AxisChar* pName, const AxisChar* pNamespace)
00564     { return ((CallBase*)pObj)->getAttributeAsDateTime(pName, pNamespace);};
00565     static struct tm AXISCALL s_GetAttributeAsDate(void* pObj,
00566         const AxisChar* pName, const AxisChar* pNamespace)
00567     { return ((CallBase*)pObj)->getAttributeAsDate(pName, pNamespace);};
00568     static struct tm AXISCALL s_GetAttributeAsTime(void* pObj,
00569         const AxisChar* pName, const AxisChar* pNamespace)
00570     { return ((CallBase*)pObj)->getAttributeAsTime(pName, pNamespace);};
00571     static long AXISCALL s_GetAttributeAsDuration(void* pObj,
00572         const AxisChar* pName, const AxisChar* pNamespace)
00573     { return ((CallBase*)pObj)->getAttributeAsDuration(pName, pNamespace);};
00574 
00575     static Axis_Array AXISCALL s_GetCmplxArray(void* pObj, void* pDZFunct,
00576         void* pCreFunct, void* pDelFunct, void* pSizeFunct,
00577         const AxisChar* pName, const AxisChar* pNamespace)
00578     {return ((CallBase*)pObj)->getCmplxArray(pDZFunct, pCreFunct, pDelFunct,
00579         pSizeFunct, pName, pNamespace);};
00580     static Axis_Array AXISCALL s_GetBasicArray(void* pObj, XSDTYPE nType,
00581         const AxisChar* pName, const AxisChar* pNamespace)
00582     {return ((CallBase*)pObj)->getBasicArray(nType, pName, pNamespace);};
00583     static void* AXISCALL s_GetCmplxObject(void* pObj, void* pDZFunct,
00584         void* pCreFunct, void* pDelFunct, const AxisChar* pName,
00585         const AxisChar* pNamespace)
00586     {return ((CallBase*)pObj)->getCmplxObject(pDZFunct, pCreFunct, pDelFunct,
00587         pName, pNamespace);};
00588 
00589     static int AXISCALL s_CheckMessage(void *pObj, const AxisChar* pName,
00590         const AxisChar* pNamespace)
00591     {return ((CallBase*)pObj)->checkMessage(pName, pNamespace);};
00592 
00593     static void* AXISCALL s_CheckFault(void *pObj, const AxisChar* pName,
00594         const AxisChar* pNamespace)
00595     {return ((CallBase*)pObj)->checkFault(pName, pNamespace);};
00596 
00597     /* Minimal error check */
00598     static int AXISCALL s_GetStatus(void *pObj)
00599     {return ((CallBase*)pObj)->getStatus();};
00600 
00601     static AnyType* AXISCALL s_GetAnyObject(void *pObj)
00602     {return ((CallBase*)pObj)->getAnyObject();};
00603 
00604     static int AXISCALL s_AddAnyObject(void *pObj, AnyType* pAnyObject)
00605     {return ((CallBase*)pObj)->addAnyObject(pAnyObject);};
00606 
00607     static const AxisChar* AXISCALL s_GetNamespacePrefix(void *pObj,
00608         const AxisChar* pNamespace)
00609     {return ((CallBase*)pObj)->getNamespacePrefix(pNamespace);};
00610 
00611     static HeaderBlock_C AXISCALL s_CreateHeaderBlock(void *pObj,
00612         AxisChar *pachLocalName, AxisChar *pachUri);
00613 
00614     /* and populate ms_VFtable with corresponding entry */
00615     static void s_Initialize();
00616 };
00617 
00618 /* A separate call class object should be used by each thread */
00619 class STORAGE_CLASS_INFO Call : public CallBase
00620 {
00621 public:
00622     Call();
00623     virtual ~Call();
00624     void AXISCALL setSOAPVersion(SOAP_VERSION version);
00625     int AXISCALL setTransportProperty(AXIS_TRANSPORT_INFORMATION_TYPE type,
00626         const char* value);
00627     int AXISCALL setProtocol(AXIS_PROTOCOL_TYPE protocol);
00628     int AXISCALL unInitialize();
00629     int AXISCALL initialize(PROVIDERTYPE nStyle, int secure);
00630     int AXISCALL invoke();
00631 
00632     /* Method for adding complex parameters */
00633     void AXISCALL addCmplxParameter(void* pObject, void* pSZFunct,
00634         void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace);
00635     /* Method for adding complex type array parameters */
00636     void AXISCALL addCmplxArrayParameter(Axis_Array* pArray, void* pSZFunct,
00637         void* pDelFunct, void* pSizeFunct, const AxisChar* pName,
00638         const AxisChar* pNamespace);
00639     /* Method for adding basic type array parameters */
00640     void AXISCALL addBasicArrayParameter(Axis_Array* pArray, XSDTYPE nType,
00641         const AxisChar* pName);
00642     /* Method for adding parameters of basic types */
00643     void AXISCALL addParameter(void* pValue,const char* pchName,
00644         XSDTYPE nType);
00645 
00646     /* Method that set the remote method name */
00647     void AXISCALL setOperation(const char* pchOperation,
00648         const char* pchNamespace);
00649     int AXISCALL setEndpointURI(const char* pchEndpointURI);
00650 public:
00651     IHeaderBlock* AXISCALL createHeaderBlock(AxisChar *pachLocalName,
00652         AxisChar *pachUri);
00653     IHeaderBlock* createHeaderBlock();
00654     int setSoapHeader(ISoapHeader *pSoapHeader);
00655     /* Methods used by stubs to get a deserialized value of XML element
00656      * as basic types
00657      */
00658     int AXISCALL getElementAsInt(const AxisChar* pName,
00659         const AxisChar* pNamespace);
00660         int AXISCALL getFaultDetail(char** ppcDetail);
00661     xsd__boolean AXISCALL getElementAsBoolean(const AxisChar* pName,
00662         const AxisChar* pNamespace);
00663     unsigned int AXISCALL getElementAsUnsignedInt(const AxisChar* pName,
00664         const AxisChar* pNamespace);
00665     short AXISCALL getElementAsShort(const AxisChar* pName,
00666         const AxisChar* pNamespace);
00667     unsigned short AXISCALL getElementAsUnsignedShort(const AxisChar* pName,
00668         const AxisChar* pNamespace);
00669     char AXISCALL getElementAsByte(const AxisChar* pName,
00670         const AxisChar* pNamespace);
00671     unsigned char AXISCALL getElementAsUnsignedByte(const AxisChar* pName,
00672         const AxisChar* pNamespace);
00673     long AXISCALL getElementAsLong(const AxisChar* pName,
00674         const AxisChar* pNamespace);
00675     long AXISCALL getElementAsInteger(const AxisChar* pName,
00676         const AxisChar* pNamespace);
00677     unsigned long AXISCALL getElementAsUnsignedLong(const AxisChar* pName,
00678         const AxisChar* pNamespace);
00679     float AXISCALL getElementAsFloat(const AxisChar* pName,
00680         const AxisChar* pNamespace);
00681     double AXISCALL getElementAsDouble(const AxisChar* pName,
00682         const AxisChar* pNamespace);
00683     double AXISCALL getElementAsDecimal(const AxisChar* pName,
00684         const AxisChar* pNamespace);
00685     AxisChar* AXISCALL getElementAsString(const AxisChar* pName,
00686         const AxisChar* pNamespace);
00687     AxisChar* AXISCALL getElementAsAnyURI(const AxisChar* pName,
00688         const AxisChar* pNamespace);
00689     AxisChar* AXISCALL getElementAsQName(const AxisChar* pName,
00690         const AxisChar* pNamespace);
00691     xsd__hexBinary AXISCALL getElementAsHexBinary(const AxisChar* pName,
00692         const AxisChar* pNamespace);
00693     xsd__base64Binary AXISCALL getElementAsBase64Binary(const AxisChar* pName,
00694         const AxisChar* pNamespace);
00695     struct tm AXISCALL getElementAsDateTime(const AxisChar* pName,
00696         const AxisChar* pNamespace);
00697     struct tm AXISCALL getElementAsDate(const AxisChar* pName,
00698         const AxisChar* pNamespace);
00699     struct tm AXISCALL getElementAsTime(const AxisChar* pName,
00700         const AxisChar* pNamespace);
00701     long AXISCALL getElementAsDuration(const AxisChar* pName,
00702         const AxisChar* pNamespace);
00703 
00704     /* Methods used by stubs to get a deserialized value of a XML attribute
00705      * as basic types
00706      */
00707     int AXISCALL getAttributeAsInt(const AxisChar* pName,
00708         const AxisChar* pNamespace);
00709     xsd__boolean AXISCALL getAttributeAsBoolean(const AxisChar* pName,
00710         const AxisChar* pNamespace);
00711     unsigned int AXISCALL getAttributeAsUnsignedInt(const AxisChar* pName,
00712         const AxisChar* pNamespace);
00713     short AXISCALL getAttributeAsShort(const AxisChar* pName,
00714         const AxisChar* pNamespace);
00715     unsigned short AXISCALL getAttributeAsUnsignedShort(const AxisChar* pName,
00716         const AxisChar* pNamespace);
00717     char AXISCALL getAttributeAsByte(const AxisChar* pName,
00718         const AxisChar* pNamespace);
00719     unsigned char AXISCALL getAttributeAsUnsignedByte(const AxisChar* pName,
00720         const AxisChar* pNamespace);
00721     long AXISCALL getAttributeAsLong(const AxisChar* pName,
00722         const AxisChar* pNamespace);
00723     long AXISCALL getAttributeAsInteger(const AxisChar* pName,
00724         const AxisChar* pNamespace);
00725     unsigned long AXISCALL getAttributeAsUnsignedLong(const AxisChar* pName,
00726         const AxisChar* pNamespace);
00727     float AXISCALL getAttributeAsFloat(const AxisChar* pName,
00728         const AxisChar* pNamespace);
00729     double AXISCALL getAttributeAsDouble(const AxisChar* pName,
00730         const AxisChar* pNamespace);
00731     double AXISCALL getAttributeAsDecimal(const AxisChar* pName,
00732         const AxisChar* pNamespace);
00733     AxisChar* AXISCALL getAttributeAsString(const AxisChar* pName,
00734         const AxisChar* pNamespace);
00735     AxisChar* AXISCALL getAttributeAsAnyURI(const AxisChar* pName,
00736         const AxisChar* pNamespace);
00737     AxisChar* AXISCALL getAttributeAsQName(const AxisChar* pName,
00738         const AxisChar* pNamespace);
00739     xsd__hexBinary AXISCALL getAttributeAsHexBinary(const AxisChar* pName,
00740         const AxisChar* pNamespace);
00741     xsd__base64Binary AXISCALL getAttributeAsBase64Binary(const AxisChar*
00742         pName, const AxisChar* pNamespace);
00743     struct tm AXISCALL getAttributeAsDateTime(const AxisChar* pName,
00744         const AxisChar* pNamespace);
00745     struct tm AXISCALL getAttributeAsDate(const AxisChar* pName,
00746         const AxisChar* pNamespace);
00747     struct tm AXISCALL getAttributeAsTime(const AxisChar* pName,
00748         const AxisChar* pNamespace);
00749     long AXISCALL getAttributeAsDuration(const AxisChar* pName,
00750         const AxisChar* pNamespace);
00751 
00752     /* Method used by stubs to get a deserialized value of complex types */
00753     void* AXISCALL getCmplxObject(void* pDZFunct, void* pCreFunct,
00754         void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace);
00755     /* Method used by stubs to get a deserialized Array of complex types */
00756     Axis_Array AXISCALL getCmplxArray(void* pDZFunct, void* pCreFunct,
00757         void* pDelFunct, void* pSizeFunct, const AxisChar* pName,
00758         const AxisChar* pNamespace);
00759     /* Method used by stubs to get a deserialized Array of basic types */
00760     Axis_Array AXISCALL getBasicArray(XSDTYPE nType, const AxisChar* pName,
00761         const AxisChar* pNamespace);
00762 
00763     int AXISCALL checkMessage(const AxisChar* pName,
00764         const AxisChar* pNamespace);
00765 
00766     void* AXISCALL checkFault(const AxisChar* pName,
00767         const AxisChar* pNamespace);
00768 
00769     int AXISCALL getStatus();
00770 
00771     SOAPTransport* getTransport() { return m_pTransport; }
00772     SoapSerializer* getSOAPSerializer() { return (SoapSerializer*)m_pIWSSZ; }
00773 
00780     void setProxy(const char* pcProxyHost, unsigned int uiProxyPort);
00781 
00782     AnyType* AXISCALL getAnyObject();
00783     int AXISCALL addAnyObject(AnyType* pAnyObject);
00784     const AxisChar* AXISCALL getNamespacePrefix(const AxisChar* pNamespace);
00785 
00786 private:
00787     int openConnection(int secure);
00788     void closeConnection();
00789     int makeArray();
00790 
00791 private:
00792     ClientAxisEngine* m_pAxisEngine;
00793     /*
00794        Following are pointers to relevant objects of the ClientAxisEngine
00795        instance. So they do not belong to this object and are not created
00796        or deleted
00797      */
00798     MessageData* m_pMsgData;
00799     SoapSerializer* m_pIWSSZ;
00800     SoapDeSerializer* m_pIWSDZ;
00801     const char* m_pcEndPointUri;
00802     AXIS_PROTOCOL_TYPE m_nTransportType;
00803     /*
00804        Transport object
00805      */
00806     SOAPTransport* m_pTransport;
00807 
00808     /* Minimal error check */
00809     int m_nStatus;
00813     string m_strProxyHost;
00817     unsigned int m_uiProxyPort;
00821     bool m_bUseProxy;
00822 
00823 };
00824 AXIS_CPP_NAMESPACE_END
00825 #endif
00826 
00827 #ifdef __cplusplus
00828 extern "C" { 
00829 #endif
00830 STORAGE_CLASS_INFO void* getStubObject(AXIS_PROTOCOL_TYPE nProtocol, 
00831                                        AxisChar* pchEndpointURI); 
00832 STORAGE_CLASS_INFO void destroyStubObject(void* pCall); 
00833 #ifdef __cplusplus
00834 } 
00835 #endif
00836 
00837 #endif

Generated on Wed Aug 18 11:42:23 2004 for AxisC++ by doxygen1.2.18