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