Main Page   Class Hierarchy   Compound List   File List   Compound Members   Examples  

Call.h

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