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

Generated on Fri Jul 9 13:18:29 2004 for AxisC++ by doxygen1.2.18