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

Generated on Fri Oct 22 18:49:04 2004 for AxisC++ by doxygen1.2.18