axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From susan...@apache.org
Subject cvs commit: ws-axis/c/include/axis/server Attribute.h AxisConfig.h AxisEngine.h AxisException.h AxisFile.h AxisMessage.h AxisTime.h AxisTrace.h BasicHandler.h BasicNode.h BasicTypeSerializer.h XMLParser.h
Date Thu, 17 Jun 2004 08:42:50 GMT
susantha    2004/06/17 01:42:50

  Modified:    c/include/axis/client Call.h
               c/include/axis/server Attribute.h AxisConfig.h AxisEngine.h
                        AxisException.h AxisFile.h AxisMessage.h AxisTime.h
                        AxisTrace.h BasicHandler.h BasicNode.h
                        BasicTypeSerializer.h XMLParser.h
  Log:
  Some file comments added to generate doxygen documentations.
  
  Revision  Changes    Path
  1.22      +412 -412  ws-axis/c/include/axis/client/Call.h
  
  Index: Call.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/client/Call.h,v
  retrieving revision 1.21
  retrieving revision 1.22
  diff -u -r1.21 -r1.22
  --- Call.h	17 Jun 2004 05:34:21 -0000	1.21
  +++ Call.h	17 Jun 2004 08:42:50 -0000	1.22
  @@ -65,122 +65,122 @@
   #endif
   
   typedef struct {
  -	void (AXISCALL* setSOAPVersion)(void* pObj, SOAP_VERSION version);
  -	int (AXISCALL* setTransportProperty)(void* pObj, 
  +    void (AXISCALL* setSOAPVersion)(void* pObj, SOAP_VERSION version);
  +    int (AXISCALL* setTransportProperty)(void* pObj,
           AXIS_TRANSPORT_INFORMATION_TYPE type, const char* value);
  -	int (AXISCALL* setProtocol)(void* pObj, AXIS_PROTOCOL_TYPE protocol);
  -	int (AXISCALL* initialize)(void* pObj, PROVIDERTYPE nStyle, int secure);
  -	int (AXISCALL* invoke)(void* pObj);
  -	int (AXISCALL* unInitialize)(void* pObj);
  +    int (AXISCALL* setProtocol)(void* pObj, AXIS_PROTOCOL_TYPE protocol);
  +    int (AXISCALL* initialize)(void* pObj, PROVIDERTYPE nStyle, int secure);
  +    int (AXISCALL* invoke)(void* pObj);
  +    int (AXISCALL* unInitialize)(void* pObj);
   
  -	/* Method that set the remote method name */
  -	void (AXISCALL* setOperation)(void* pObj, const char* pchOperation, 
  +    /* Method that set the remote method name */
  +    void (AXISCALL* setOperation)(void* pObj, const char* pchOperation,
           const char* pchNamespace);
  -	int (AXISCALL* setEndpointURI)(void* pObj, const char* pchEndpointURI);
  +    int (AXISCALL* setEndpointURI)(void* pObj, const char* pchEndpointURI);
   
  -	/* Method for adding complex parameters */
  -	void (AXISCALL* addCmplxParameter)(void* pObj, void* pObject, 
  -        void* pSZFunct, void* pDelFunct, const AxisChar* pName, 
  +    /* Method for adding complex parameters */
  +    void (AXISCALL* addCmplxParameter)(void* pObj, void* pObject,
  +        void* pSZFunct, void* pDelFunct, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	/* Method for adding complex type array parameters */
  -	void (AXISCALL* addCmplxArrayParameter)(void* pObj, Axis_Array* pArray,
  +    /* Method for adding complex type array parameters */
  +    void (AXISCALL* addCmplxArrayParameter)(void* pObj, Axis_Array* pArray,
           void* pSZFunct, void* pDelFunct, void* pSizeFunct,
           const AxisChar* pName, const AxisChar* pNamespace);
  -	/* Method for adding basic type array parameters */
  -	void (AXISCALL* addBasicArrayParameter)(void* pObj, Axis_Array* pArray,
  +    /* Method for adding basic type array parameters */
  +    void (AXISCALL* addBasicArrayParameter)(void* pObj, Axis_Array* pArray,
           XSDTYPE nType, const char* pName);
  -	/* Method for adding parameters of basic types */
  -	void (AXISCALL* addParameter)(void* pObj, void* pValue,const char* pName,
  +    /* Method for adding parameters of basic types */
  +    void (AXISCALL* addParameter)(void* pObj, void* pValue,const char* pName,
           XSDTYPE nType);
   
  -	/* Methods used by stubs to get a deserialized value of an XML element 
  -     * as basic types 
  +    /* Methods used by stubs to get a deserialized value of an XML element
  +     * as basic types
        */
  -	int (AXISCALL* getElementAsInt)(void* pObj, const AxisChar* pName, 
  +    int (AXISCALL* getElementAsInt)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	xsd__boolean (AXISCALL* getElementAsBoolean)(void* pObj, 
  +    xsd__boolean (AXISCALL* getElementAsBoolean)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    unsigned int (AXISCALL* getElementAsUnsignedInt)(void* pObj, 
  +    unsigned int (AXISCALL* getElementAsUnsignedInt)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    short (AXISCALL* getElementAsShort)(void* pObj, const AxisChar* pName, 
  +    short (AXISCALL* getElementAsShort)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned short (AXISCALL* getElementAsUnsignedShort)(void* pObj, 
  +    unsigned short (AXISCALL* getElementAsUnsignedShort)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    char (AXISCALL* getElementAsByte)(void* pObj, const AxisChar* pName, 
  +    char (AXISCALL* getElementAsByte)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
       unsigned char (AXISCALL* getElementAsUnsignedByte)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    long (AXISCALL* getElementAsLong)(void* pObj, const AxisChar* pName, 
  +    long (AXISCALL* getElementAsLong)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    long (AXISCALL* getElementAsInteger)(void* pObj, const AxisChar* pName, 
  +    long (AXISCALL* getElementAsInteger)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned long (AXISCALL* getElementAsUnsignedLong)(void* pObj, 
  +    unsigned long (AXISCALL* getElementAsUnsignedLong)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -	float (AXISCALL* getElementAsFloat)(void* pObj, const AxisChar* pName, 
  +    float (AXISCALL* getElementAsFloat)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    double (AXISCALL* getElementAsDouble)(void* pObj, const AxisChar* pName, 
  +    double (AXISCALL* getElementAsDouble)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    double (AXISCALL* getElementAsDecimal)(void* pObj, const AxisChar* pName, 
  +    double (AXISCALL* getElementAsDecimal)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	AxisChar* (AXISCALL* getElementAsString)(void* pObj, const AxisChar* pName, 
  +    AxisChar* (AXISCALL* getElementAsString)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    AxisChar* (AXISCALL* getElementAsAnyURI)(void* pObj, const AxisChar* pName, 
  +    AxisChar* (AXISCALL* getElementAsAnyURI)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    AxisChar* (AXISCALL* getElementAsQName)(void* pObj, const AxisChar* pName, 
  +    AxisChar* (AXISCALL* getElementAsQName)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	xsd__hexBinary (AXISCALL* getElementAsHexBinary)(void* pObj, 
  +    xsd__hexBinary (AXISCALL* getElementAsHexBinary)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -	xsd__base64Binary (AXISCALL* getElementAsBase64Binary)(void* pObj, 
  +    xsd__base64Binary (AXISCALL* getElementAsBase64Binary)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    struct tm (AXISCALL* getElementAsDateTime)(void* pObj, 
  +    struct tm (AXISCALL* getElementAsDateTime)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
       struct tm (AXISCALL* getElementAsDate)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    struct tm (AXISCALL* getElementAsTime)(void* pObj, const AxisChar* pName, 
  +    struct tm (AXISCALL* getElementAsTime)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    long (AXISCALL* getElementAsDuration)(void* pObj, const AxisChar* pName, 
  +    long (AXISCALL* getElementAsDuration)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
   
  -	/* Methods used by stubs to get a deserialized value of an XML attribute 
  -     * basic types 
  +    /* Methods used by stubs to get a deserialized value of an XML attribute
  +     * basic types
        */
  -	int (AXISCALL* getAttributeAsInt)(void* pObj, const AxisChar* pName, 
  +    int (AXISCALL* getAttributeAsInt)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	xsd__boolean (AXISCALL* getAttributeAsBoolean)(void* pObj, 
  +    xsd__boolean (AXISCALL* getAttributeAsBoolean)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    unsigned int (AXISCALL* getAttributeAsUnsignedInt)(void* pObj, 
  +    unsigned int (AXISCALL* getAttributeAsUnsignedInt)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    short (AXISCALL* getAttributeAsShort)(void* pObj, const AxisChar* pName, 
  +    short (AXISCALL* getAttributeAsShort)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned short (AXISCALL* getAttributeAsUnsignedShort)(void* pObj, 
  +    unsigned short (AXISCALL* getAttributeAsUnsignedShort)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    char (AXISCALL* getAttributeAsByte)(void* pObj, const AxisChar* pName, 
  +    char (AXISCALL* getAttributeAsByte)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned char (AXISCALL* getAttributeAsUnsignedByte)(void* pObj, 
  +    unsigned char (AXISCALL* getAttributeAsUnsignedByte)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    long (AXISCALL* getAttributeAsLong)(void* pObj, const AxisChar* pName, 
  +    long (AXISCALL* getAttributeAsLong)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    long (AXISCALL* getAttributeAsInteger)(void* pObj, const AxisChar* pName, 
  +    long (AXISCALL* getAttributeAsInteger)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned long (AXISCALL* getAttributeAsUnsignedLong)(void* pObj, 
  +    unsigned long (AXISCALL* getAttributeAsUnsignedLong)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -	float (AXISCALL* getAttributeAsFloat)(void* pObj, const AxisChar* pName, 
  +    float (AXISCALL* getAttributeAsFloat)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -    double (AXISCALL* getAttributeAsDouble)(void* pObj, const AxisChar* pName, 
  +    double (AXISCALL* getAttributeAsDouble)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
       double (AXISCALL* getAttributeAsDecimal)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	AxisChar* (AXISCALL* getAttributeAsString)(void* pObj, 
  +    AxisChar* (AXISCALL* getAttributeAsString)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    AxisChar* (AXISCALL* getAttributeAsAnyURI)(void* pObj, 
  +    AxisChar* (AXISCALL* getAttributeAsAnyURI)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    AxisChar* (AXISCALL* getAttributeAsQName)(void* pObj, 
  +    AxisChar* (AXISCALL* getAttributeAsQName)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -	xsd__hexBinary (AXISCALL* getAttributeAsHexBinary)(void* pObj, 
  +    xsd__hexBinary (AXISCALL* getAttributeAsHexBinary)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -	xsd__base64Binary (AXISCALL* getAttributeAsBase64Binary)(void* pObj, 
  +    xsd__base64Binary (AXISCALL* getAttributeAsBase64Binary)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
  -    struct tm (AXISCALL* getAttributeAsDateTime)(void* pObj, 
  +    struct tm (AXISCALL* getAttributeAsDateTime)(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace);
       struct tm (AXISCALL* getAttributeAsDate)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  @@ -189,26 +189,26 @@
       long (AXISCALL* getAttributeAsDuration)(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
   
  -	/* Method used by stubs to get a deserialized value of complex types */
  -	void* (AXISCALL* getCmplxObject)(void* pObj, void* pDZFunct, 
  -        void* pCreFunct, void* pDelFunct, const AxisChar* pName, 
  +    /* Method used by stubs to get a deserialized value of complex types */
  +    void* (AXISCALL* getCmplxObject)(void* pObj, void* pDZFunct,
  +        void* pCreFunct, void* pDelFunct, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	/* Method used by stubs to get a deserialized Array of complex types */
  -	Axis_Array (AXISCALL* getCmplxArray)(void* pObj, void* pDZFunct, 
  -        void* pCreFunct, void* pDelFunct, void* pSizeFunct, 
  +    /* Method used by stubs to get a deserialized Array of complex types */
  +    Axis_Array (AXISCALL* getCmplxArray)(void* pObj, void* pDZFunct,
  +        void* pCreFunct, void* pDelFunct, void* pSizeFunct,
           const AxisChar* pName, const AxisChar* pNamespace);
  -	/* Method used by stubs to get a deserialized Array of basic types */
  -	Axis_Array (AXISCALL* getBasicArray)(void* pObj, XSDTYPE nType, 
  +    /* Method used by stubs to get a deserialized Array of basic types */
  +    Axis_Array (AXISCALL* getBasicArray)(void* pObj, XSDTYPE nType,
           const AxisChar* pName, const AxisChar* pNamespace);
   
  -	int (AXISCALL* checkMessage)(void *pObj, const AxisChar* pName, 
  +    int (AXISCALL* checkMessage)(void *pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
   
  -	int (AXISCALL* checkFault)(void *pObj, const AxisChar* pName, 
  +    int (AXISCALL* checkFault)(void *pObj, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	
  -	/* Minimal error check */
  -	int (AXISCALL* getStatus)(void *pObj);
  +
  +    /* Minimal error check */
  +    int (AXISCALL* getStatus)(void *pObj);
   
       AnyType* (AXISCALL* getAnyObject)(void *pObj);
   
  @@ -217,7 +217,7 @@
       const AxisChar* (AXISCALL* getNamespacePrefix)(void *pObj,
           const AxisChar* pNamespace);
   
  -	HeaderBlock_C (AXISCALL* createHeaderBlock)(void *pObj, 
  +    HeaderBlock_C (AXISCALL* createHeaderBlock)(void *pObj,
           AxisChar *pachLocalName, AxisChar *pachUri);
   
   } CallFunctions;
  @@ -225,577 +225,577 @@
   #ifdef __cplusplus
   
   class STORAGE_CLASS_INFO CallBase
  -{	
  +{
   public:
  -	virtual void AXISCALL setSOAPVersion(SOAP_VERSION version)=0;
  -	virtual int AXISCALL setTransportProperty(AXIS_TRANSPORT_INFORMATION_TYPE 
  +    virtual void AXISCALL setSOAPVersion(SOAP_VERSION version)=0;
  +    virtual int AXISCALL setTransportProperty(AXIS_TRANSPORT_INFORMATION_TYPE
           type, const char* value)=0;
  -	virtual int AXISCALL setProtocol(AXIS_PROTOCOL_TYPE protocol)=0;
  -	virtual int AXISCALL initialize(PROVIDERTYPE nStyle, int secure)=0;
  -	virtual int AXISCALL invoke()=0;
  -	virtual int AXISCALL unInitialize()=0;
  +    virtual int AXISCALL setProtocol(AXIS_PROTOCOL_TYPE protocol)=0;
  +    virtual int AXISCALL initialize(PROVIDERTYPE nStyle, int secure)=0;
  +    virtual int AXISCALL invoke()=0;
  +    virtual int AXISCALL unInitialize()=0;
   
  -	/* Method that set the remote method name */
  -	virtual void AXISCALL setOperation(const char* pchOperation, 
  +    /* Method that set the remote method name */
  +    virtual void AXISCALL setOperation(const char* pchOperation,
           const char* pchNamespace)=0;
  -	virtual int AXISCALL setEndpointURI(const char* pchEndpointURI)=0;
  +    virtual int AXISCALL setEndpointURI(const char* pchEndpointURI)=0;
   
  -	/* Method for adding complex parameters */
  -	virtual void AXISCALL addCmplxParameter(void* pObject, void* pSZFunct, 
  +    /* Method for adding complex parameters */
  +    virtual void AXISCALL addCmplxParameter(void* pObject, void* pSZFunct,
           void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace)=0;
  -	/* Method for adding complex type array parameters */
  -	virtual void AXISCALL addCmplxArrayParameter(Axis_Array* pArray, 
  -        void* pSZFunct, void* pDelFunct, void* pSizeFunct, 
  +    /* Method for adding complex type array parameters */
  +    virtual void AXISCALL addCmplxArrayParameter(Axis_Array* pArray,
  +        void* pSZFunct, void* pDelFunct, void* pSizeFunct,
           const AxisChar* pName, const AxisChar* pNamespace)=0;
  -	/* Method for adding basic type array parameters */
  -	virtual void AXISCALL addBasicArrayParameter(Axis_Array* pArray, 
  +    /* Method for adding basic type array parameters */
  +    virtual void AXISCALL addBasicArrayParameter(Axis_Array* pArray,
           XSDTYPE nType, const char* pName)=0;
  -	/* Method for adding parameters of basic types */
  -	virtual void AXISCALL addParameter(void* pValue,const char* pName, 
  +    /* Method for adding parameters of basic types */
  +    virtual void AXISCALL addParameter(void* pValue,const char* pName,
           XSDTYPE nType)=0;
   
  -	/* Methods used by stubs to get a deserialized value of an XML element 
  -     * as basic types 
  +    /* Methods used by stubs to get a deserialized value of an XML element
  +     * as basic types
        */
  -	virtual int AXISCALL getElementAsInt(const AxisChar* pName, 
  +    virtual int AXISCALL getElementAsInt(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -	virtual xsd__boolean AXISCALL getElementAsBoolean(const AxisChar* pName, 
  +    virtual xsd__boolean AXISCALL getElementAsBoolean(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual unsigned int AXISCALL getElementAsUnsignedInt(const AxisChar* 
  +    virtual unsigned int AXISCALL getElementAsUnsignedInt(const AxisChar*
           pName, const AxisChar* pNamespace)=0;
  -    virtual short AXISCALL getElementAsShort(const AxisChar* pName, 
  +    virtual short AXISCALL getElementAsShort(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual unsigned short AXISCALL getElementAsUnsignedShort(const AxisChar* 
  +    virtual unsigned short AXISCALL getElementAsUnsignedShort(const AxisChar*
           pName, const AxisChar* pNamespace)=0;
  -    virtual char AXISCALL getElementAsByte(const AxisChar* pName, 
  +    virtual char AXISCALL getElementAsByte(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual unsigned char AXISCALL getElementAsUnsignedByte(const AxisChar* 
  +    virtual unsigned char AXISCALL getElementAsUnsignedByte(const AxisChar*
           pName, const AxisChar* pNamespace)=0;
  -    virtual long AXISCALL getElementAsLong(const AxisChar* pName, 
  +    virtual long AXISCALL getElementAsLong(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual long AXISCALL getElementAsInteger(const AxisChar* pName, 
  +    virtual long AXISCALL getElementAsInteger(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual unsigned long AXISCALL getElementAsUnsignedLong(const AxisChar* 
  +    virtual unsigned long AXISCALL getElementAsUnsignedLong(const AxisChar*
           pName, const AxisChar* pNamespace)=0;
  -	virtual float AXISCALL getElementAsFloat(const AxisChar* pName, 
  +    virtual float AXISCALL getElementAsFloat(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual double AXISCALL getElementAsDouble(const AxisChar* pName, 
  +    virtual double AXISCALL getElementAsDouble(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual double AXISCALL getElementAsDecimal(const AxisChar* pName, 
  +    virtual double AXISCALL getElementAsDecimal(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -	virtual AxisChar* AXISCALL getElementAsString(const AxisChar* pName, 
  +    virtual AxisChar* AXISCALL getElementAsString(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual AxisChar* AXISCALL getElementAsAnyURI(const AxisChar* pName, 
  +    virtual AxisChar* AXISCALL getElementAsAnyURI(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual AxisChar* AXISCALL getElementAsQName(const AxisChar* pName, 
  +    virtual AxisChar* AXISCALL getElementAsQName(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -	virtual xsd__hexBinary AXISCALL getElementAsHexBinary(const AxisChar* 
  +    virtual xsd__hexBinary AXISCALL getElementAsHexBinary(const AxisChar*
           pName, const AxisChar* pNamespace)=0;
  -	virtual xsd__base64Binary AXISCALL getElementAsBase64Binary(const 
  +    virtual xsd__base64Binary AXISCALL getElementAsBase64Binary(const
           AxisChar* pName, const AxisChar* pNamespace)=0;
  -    virtual struct tm AXISCALL getElementAsDateTime(const AxisChar* pName, 
  +    virtual struct tm AXISCALL getElementAsDateTime(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual struct tm AXISCALL getElementAsDate(const AxisChar* pName, 
  +    virtual struct tm AXISCALL getElementAsDate(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual struct tm AXISCALL getElementAsTime(const AxisChar* pName, 
  +    virtual struct tm AXISCALL getElementAsTime(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual long AXISCALL getElementAsDuration(const AxisChar* pName, 
  +    virtual long AXISCALL getElementAsDuration(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
   
  -	/* Methods used by stubs to get a deserialized value of XML attribute 
  -     * as basic types 
  +    /* Methods used by stubs to get a deserialized value of XML attribute
  +     * as basic types
        */
  -	virtual int AXISCALL getAttributeAsInt(const AxisChar* pName, 
  +    virtual int AXISCALL getAttributeAsInt(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -	virtual xsd__boolean AXISCALL getAttributeAsBoolean(const AxisChar* pName,
  +    virtual xsd__boolean AXISCALL getAttributeAsBoolean(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual unsigned int AXISCALL getAttributeAsUnsignedInt(const AxisChar* 
  +    virtual unsigned int AXISCALL getAttributeAsUnsignedInt(const AxisChar*
           pName, const AxisChar* pNamespace)=0;
  -    virtual short AXISCALL getAttributeAsShort(const AxisChar* pName, 
  +    virtual short AXISCALL getAttributeAsShort(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual unsigned short AXISCALL getAttributeAsUnsignedShort(const 
  +    virtual unsigned short AXISCALL getAttributeAsUnsignedShort(const
           AxisChar* pName, const AxisChar* pNamespace)=0;
  -    virtual char AXISCALL getAttributeAsByte(const AxisChar* pName, 
  +    virtual char AXISCALL getAttributeAsByte(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual unsigned char AXISCALL getAttributeAsUnsignedByte(const AxisChar* 
  +    virtual unsigned char AXISCALL getAttributeAsUnsignedByte(const AxisChar*
           pName, const AxisChar* pNamespace)=0;
  -    virtual long AXISCALL getAttributeAsLong(const AxisChar* pName, 
  +    virtual long AXISCALL getAttributeAsLong(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual long AXISCALL getAttributeAsInteger(const AxisChar* pName, 
  +    virtual long AXISCALL getAttributeAsInteger(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual unsigned long AXISCALL getAttributeAsUnsignedLong(const AxisChar* 
  +    virtual unsigned long AXISCALL getAttributeAsUnsignedLong(const AxisChar*
           pName, const AxisChar* pNamespace)=0;
  -	virtual float AXISCALL getAttributeAsFloat(const AxisChar* pName, 
  +    virtual float AXISCALL getAttributeAsFloat(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual double AXISCALL getAttributeAsDouble(const AxisChar* pName, 
  +    virtual double AXISCALL getAttributeAsDouble(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual double AXISCALL getAttributeAsDecimal(const AxisChar* pName, 
  +    virtual double AXISCALL getAttributeAsDecimal(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -	virtual AxisChar* AXISCALL getAttributeAsString(const AxisChar* pName, 
  +    virtual AxisChar* AXISCALL getAttributeAsString(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual AxisChar* AXISCALL getAttributeAsAnyURI(const AxisChar* pName, 
  +    virtual AxisChar* AXISCALL getAttributeAsAnyURI(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual AxisChar* AXISCALL getAttributeAsQName(const AxisChar* pName, 
  +    virtual AxisChar* AXISCALL getAttributeAsQName(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -	virtual xsd__hexBinary AXISCALL getAttributeAsHexBinary(const AxisChar* 
  +    virtual xsd__hexBinary AXISCALL getAttributeAsHexBinary(const AxisChar*
           pName, const AxisChar* pNamespace)=0;
  -	virtual xsd__base64Binary AXISCALL getAttributeAsBase64Binary(const 
  +    virtual xsd__base64Binary AXISCALL getAttributeAsBase64Binary(const
           AxisChar* pName, const AxisChar* pNamespace)=0;
  -    virtual struct tm AXISCALL getAttributeAsDateTime(const AxisChar* pName, 
  +    virtual struct tm AXISCALL getAttributeAsDateTime(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual struct tm AXISCALL getAttributeAsDate(const AxisChar* pName, 
  +    virtual struct tm AXISCALL getAttributeAsDate(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual struct tm AXISCALL getAttributeAsTime(const AxisChar* pName, 
  +    virtual struct tm AXISCALL getAttributeAsTime(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -    virtual long AXISCALL getAttributeAsDuration(const AxisChar* pName, 
  +    virtual long AXISCALL getAttributeAsDuration(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
   
  -	/* Method used by stubs to get a deserialized value of complex types */
  -	virtual void* AXISCALL getCmplxObject(void* pDZFunct, void* pCreFunct, 
  +    /* Method used by stubs to get a deserialized value of complex types */
  +    virtual void* AXISCALL getCmplxObject(void* pDZFunct, void* pCreFunct,
           void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace)=0;
  -	/* Method used by stubs to get a deserialized Array of complex types */
  -	virtual Axis_Array AXISCALL getCmplxArray(void* pDZFunct, void* pCreFunct, 
  -        void* pDelFunct, void* pSizeFunct, const AxisChar* pName, 
  +    /* Method used by stubs to get a deserialized Array of complex types */
  +    virtual Axis_Array AXISCALL getCmplxArray(void* pDZFunct, void* pCreFunct,
  +        void* pDelFunct, void* pSizeFunct, const AxisChar* pName,
           const AxisChar* pNamespace)=0;
  -	/* Method used by stubs to get a deserialized Array of basic types */
  -	virtual Axis_Array AXISCALL getBasicArray(XSDTYPE nType, 
  +    /* Method used by stubs to get a deserialized Array of basic types */
  +    virtual Axis_Array AXISCALL getBasicArray(XSDTYPE nType,
           const AxisChar* pName, const AxisChar* pNamespace)=0;
   
  -	virtual int AXISCALL checkMessage(const AxisChar* pName, 
  +    virtual int AXISCALL checkMessage(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
   
  -	virtual int AXISCALL checkFault(const AxisChar* pName, 
  +    virtual int AXISCALL checkFault(const AxisChar* pName,
           const AxisChar* pNamespace)=0;
   
  -	/* Minimal error check */
  -	virtual int AXISCALL getStatus()=0;
  -		
  -	virtual AnyType* AXISCALL getAnyObject()=0;
  -	virtual int AXISCALL addAnyObject(AnyType* pAnyObject)=0;
  +    /* Minimal error check */
  +    virtual int AXISCALL getStatus()=0;
  +
  +    virtual AnyType* AXISCALL getAnyObject()=0;
  +    virtual int AXISCALL addAnyObject(AnyType* pAnyObject)=0;
       virtual const AxisChar* AXISCALL getNamespacePrefix
           (const AxisChar* pNamespace)=0;
   
  -    virtual IHeaderBlock* AXISCALL createHeaderBlock(AxisChar *pachLocalName, 
  +    virtual IHeaderBlock* AXISCALL createHeaderBlock(AxisChar *pachLocalName,
           AxisChar *pachUri)=0;
   
  -	/* following stuff is needed to provide the interface for C web services */
  +    /* following stuff is needed to provide the interface for C web services */
   public:
  -	static CallFunctions ms_VFtable;
  -	static bool bInitialized;
  -	/* add static functions for all interface functions here */
  -	static void AXISCALL s_SetSOAPVersion(void* pObj, SOAP_VERSION version)
  -	{((CallBase*)pObj)->setSOAPVersion(version);};
  -	static int AXISCALL s_SetTransportProperty(void* pObj, 
  +    static CallFunctions ms_VFtable;
  +    static bool bInitialized;
  +    /* add static functions for all interface functions here */
  +    static void AXISCALL s_SetSOAPVersion(void* pObj, SOAP_VERSION version)
  +    {((CallBase*)pObj)->setSOAPVersion(version);};
  +    static int AXISCALL s_SetTransportProperty(void* pObj,
           AXIS_TRANSPORT_INFORMATION_TYPE type, const char* value)
  -	{ return ((CallBase*)pObj)->setTransportProperty(type,value);};
  -	static int AXISCALL s_SetProtocol(void* pObj, AXIS_PROTOCOL_TYPE protocol)
  -	{ return ((CallBase*)pObj)->setProtocol(protocol);};
  -	static int AXISCALL s_InitializeCall(void* pObj, PROVIDERTYPE nStyle, 
  +    { return ((CallBase*)pObj)->setTransportProperty(type,value);};
  +    static int AXISCALL s_SetProtocol(void* pObj, AXIS_PROTOCOL_TYPE protocol)
  +    { return ((CallBase*)pObj)->setProtocol(protocol);};
  +    static int AXISCALL s_InitializeCall(void* pObj, PROVIDERTYPE nStyle,
           int secure)
  -	{ return ((CallBase*)pObj)->initialize(nStyle, secure);};
  -	static int AXISCALL s_Invoke(void* pObj)
  -	{ return ((CallBase*)pObj)->invoke();};
  -	static int AXISCALL s_UnInitialize(void* pObj)
  -	{ return ((CallBase*)pObj)->unInitialize();};
  +    { return ((CallBase*)pObj)->initialize(nStyle, secure);};
  +    static int AXISCALL s_Invoke(void* pObj)
  +    { return ((CallBase*)pObj)->invoke();};
  +    static int AXISCALL s_UnInitialize(void* pObj)
  +    { return ((CallBase*)pObj)->unInitialize();};
   
  -	/* Method that set the remote method name */
  -	static void AXISCALL s_SetOperation(void* pObj, const char* pchOperation, 
  +    /* Method that set the remote method name */
  +    static void AXISCALL s_SetOperation(void* pObj, const char* pchOperation,
           const char* pchNamespace)
  -	{ ((CallBase*)pObj)->setOperation(pchOperation, pchNamespace);};
  -	static int AXISCALL s_SetEndpointURI(void* pObj, 
  +    { ((CallBase*)pObj)->setOperation(pchOperation, pchNamespace);};
  +    static int AXISCALL s_SetEndpointURI(void* pObj,
           const char* pchEndpointURI)
  -	{ return ((CallBase*)pObj)->setEndpointURI(pchEndpointURI);};
  +    { return ((CallBase*)pObj)->setEndpointURI(pchEndpointURI);};
   
  -	static void AXISCALL s_AddParameter(void* pObj, void* pValue, 
  +    static void AXISCALL s_AddParameter(void* pObj, void* pValue,
           const AxisChar* pchName, XSDTYPE type)
  -	{ ((CallBase*)pObj)->addParameter(pValue, pchName, type);};
  -	static void AXISCALL s_AddCmplxArrayParameter(void* pObj, 
  +    { ((CallBase*)pObj)->addParameter(pValue, pchName, type);};
  +    static void AXISCALL s_AddCmplxArrayParameter(void* pObj,
           Axis_Array* pArray, void* pSZFunct, void* pDelFunct, void* pSizeFunct,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ ((CallBase*)pObj)->addCmplxArrayParameter(pArray, pSZFunct, pDelFunct, 
  -		pSizeFunct, pName, pNamespace);};
  -	static void AXISCALL s_AddBasicArrayParameter(void* pObj, 
  +    { ((CallBase*)pObj)->addCmplxArrayParameter(pArray, pSZFunct, pDelFunct,
  +        pSizeFunct, pName, pNamespace);};
  +    static void AXISCALL s_AddBasicArrayParameter(void* pObj,
           Axis_Array* pArray, XSDTYPE nType, const AxisChar* pName)
  -	{ ((CallBase*)pObj)->addBasicArrayParameter(pArray, nType, pName);};
  -	static void AXISCALL s_AddCmplxParameter(void* pObj, void* pObject, 
  -        void* pDZFunct, void* pDelFunct, const AxisChar* pName, 
  +    { ((CallBase*)pObj)->addBasicArrayParameter(pArray, nType, pName);};
  +    static void AXISCALL s_AddCmplxParameter(void* pObj, void* pObject,
  +        void* pDZFunct, void* pDelFunct, const AxisChar* pName,
           const AxisChar* pNamespace)
  -	{ ((CallBase*)pObj)->addCmplxParameter(pObject, pDZFunct, pDelFunct, pName,
  -		pNamespace);};
  +    { ((CallBase*)pObj)->addCmplxParameter(pObject, pDZFunct, pDelFunct, pName,
  +        pNamespace);};
   
  -	static int AXISCALL s_GetElementAsInt(void* pObj, const AxisChar* pName, 
  +    static int AXISCALL s_GetElementAsInt(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsInt(pName, pNamespace);};
  -	static xsd__boolean AXISCALL s_GetElementAsBoolean(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsInt(pName, pNamespace);};
  +    static xsd__boolean AXISCALL s_GetElementAsBoolean(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsBoolean(pName, pNamespace);};
  -    static unsigned int AXISCALL s_GetElementAsUnsignedInt(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsBoolean(pName, pNamespace);};
  +    static unsigned int AXISCALL s_GetElementAsUnsignedInt(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsUnsignedInt(pName, pNamespace);};
  -    static short AXISCALL s_GetElementAsShort(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsUnsignedInt(pName, pNamespace);};
  +    static short AXISCALL s_GetElementAsShort(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsShort(pName, pNamespace);};
  -    static unsigned short AXISCALL s_GetElementAsUnsignedShort(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsShort(pName, pNamespace);};
  +    static unsigned short AXISCALL s_GetElementAsUnsignedShort(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsUnsignedShort(pName, pNamespace);};
  -    static char AXISCALL s_GetElementAsByte(void* pObj, const AxisChar* pName, 
  +    { return ((CallBase*)pObj)->getElementAsUnsignedShort(pName, pNamespace);};
  +    static char AXISCALL s_GetElementAsByte(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsByte(pName, pNamespace);};
  -    static unsigned char AXISCALL s_GetElementAsUnsignedByte(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsByte(pName, pNamespace);};
  +    static unsigned char AXISCALL s_GetElementAsUnsignedByte(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsUnsignedByte(pName, pNamespace);};
  -    static long AXISCALL s_GetElementAsLong(void* pObj, const AxisChar* pName, 
  +    { return ((CallBase*)pObj)->getElementAsUnsignedByte(pName, pNamespace);};
  +    static long AXISCALL s_GetElementAsLong(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsLong(pName, pNamespace);};
  -    static long AXISCALL s_GetElementAsInteger(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsLong(pName, pNamespace);};
  +    static long AXISCALL s_GetElementAsInteger(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsInteger(pName, pNamespace);};
  -    static unsigned long AXISCALL s_GetElementAsUnsignedLong(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsInteger(pName, pNamespace);};
  +    static unsigned long AXISCALL s_GetElementAsUnsignedLong(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsUnsignedLong(pName, pNamespace);};
  -	static float AXISCALL s_GetElementAsFloat(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsUnsignedLong(pName, pNamespace);};
  +    static float AXISCALL s_GetElementAsFloat(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsFloat(pName, pNamespace);};
  -    static double AXISCALL s_GetElementAsDouble(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsFloat(pName, pNamespace);};
  +    static double AXISCALL s_GetElementAsDouble(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsDouble(pName, pNamespace);};
  -    static double AXISCALL s_GetElementAsDecimal(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsDouble(pName, pNamespace);};
  +    static double AXISCALL s_GetElementAsDecimal(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsDouble(pName, pNamespace);};
  -	static AxisChar* AXISCALL s_GetElementAsString(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsDouble(pName, pNamespace);};
  +    static AxisChar* AXISCALL s_GetElementAsString(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsString(pName, pNamespace);};
  -    static AxisChar* AXISCALL s_GetElementAsAnyURI(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsString(pName, pNamespace);};
  +    static AxisChar* AXISCALL s_GetElementAsAnyURI(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsAnyURI(pName, pNamespace);};
  -    static AxisChar* AXISCALL s_GetElementAsQName(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsAnyURI(pName, pNamespace);};
  +    static AxisChar* AXISCALL s_GetElementAsQName(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsQName(pName, pNamespace);};
  -	static xsd__hexBinary AXISCALL s_GetElementAsHexBinary(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsQName(pName, pNamespace);};
  +    static xsd__hexBinary AXISCALL s_GetElementAsHexBinary(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsHexBinary(pName, pNamespace);};
  -	static xsd__base64Binary AXISCALL s_GetElementAsBase64Binary(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsHexBinary(pName, pNamespace);};
  +    static xsd__base64Binary AXISCALL s_GetElementAsBase64Binary(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsBase64Binary(pName, pNamespace);};
  -    static struct tm AXISCALL s_GetElementAsDateTime(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsBase64Binary(pName, pNamespace);};
  +    static struct tm AXISCALL s_GetElementAsDateTime(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsDateTime(pName, pNamespace);};
  -    static struct tm AXISCALL s_GetElementAsDate(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsDateTime(pName, pNamespace);};
  +    static struct tm AXISCALL s_GetElementAsDate(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsDate(pName, pNamespace);};
  -    static struct tm AXISCALL s_GetElementAsTime(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsDate(pName, pNamespace);};
  +    static struct tm AXISCALL s_GetElementAsTime(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsTime(pName, pNamespace);};
  -    static long AXISCALL s_GetElementAsDuration(void* pObj, 
  +    { return ((CallBase*)pObj)->getElementAsTime(pName, pNamespace);};
  +    static long AXISCALL s_GetElementAsDuration(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getElementAsDuration(pName, pNamespace);};
  +    { return ((CallBase*)pObj)->getElementAsDuration(pName, pNamespace);};
   
  -	static int AXISCALL s_GetAttributeAsInt(void* pObj, const AxisChar* pName,
  +    static int AXISCALL s_GetAttributeAsInt(void* pObj, const AxisChar* pName,
           const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsInt(pName, pNamespace);};
  -	static xsd__boolean AXISCALL s_GetAttributeAsBoolean(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsInt(pName, pNamespace);};
  +    static xsd__boolean AXISCALL s_GetAttributeAsBoolean(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsBoolean(pName, pNamespace);};
  -    static unsigned int AXISCALL s_GetAttributeAsUnsignedInt(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsBoolean(pName, pNamespace);};
  +    static unsigned int AXISCALL s_GetAttributeAsUnsignedInt(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsUnsignedInt(pName, pNamespace);};
  -    static short AXISCALL s_GetAttributeAsShort(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsUnsignedInt(pName, pNamespace);};
  +    static short AXISCALL s_GetAttributeAsShort(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsShort(pName, pNamespace);};
  +    { return ((CallBase*)pObj)->getAttributeAsShort(pName, pNamespace);};
       static unsigned short AXISCALL s_GetAttributeAsUnsignedShort(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsUnsignedShort(pName, 
  -		pNamespace);};
  -    static char AXISCALL s_GetAttributeAsByte(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsUnsignedShort(pName,
  +        pNamespace);};
  +    static char AXISCALL s_GetAttributeAsByte(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsByte(pName, pNamespace);};
  -    static unsigned char AXISCALL s_GetAttributeAsUnsignedByte(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsByte(pName, pNamespace);};
  +    static unsigned char AXISCALL s_GetAttributeAsUnsignedByte(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsUnsignedByte(pName, 
  -		pNamespace);};
  -    static long AXISCALL s_GetAttributeAsLong(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsUnsignedByte(pName,
  +        pNamespace);};
  +    static long AXISCALL s_GetAttributeAsLong(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsLong(pName, pNamespace);};
  -    static long AXISCALL s_GetAttributeAsInteger(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsLong(pName, pNamespace);};
  +    static long AXISCALL s_GetAttributeAsInteger(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsInteger(pName, pNamespace);};
  -    static unsigned long AXISCALL s_GetAttributeAsUnsignedLong(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsInteger(pName, pNamespace);};
  +    static unsigned long AXISCALL s_GetAttributeAsUnsignedLong(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsUnsignedLong(pName, 
  -		pNamespace);};
  -	static float AXISCALL s_GetAttributeAsFloat(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsUnsignedLong(pName,
  +        pNamespace);};
  +    static float AXISCALL s_GetAttributeAsFloat(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsFloat(pName, pNamespace);};
  -    static double AXISCALL s_GetAttributeAsDouble(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsFloat(pName, pNamespace);};
  +    static double AXISCALL s_GetAttributeAsDouble(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsDouble(pName, pNamespace);};
  -    static double AXISCALL s_GetAttributeAsDecimal(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsDouble(pName, pNamespace);};
  +    static double AXISCALL s_GetAttributeAsDecimal(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsDecimal(pName, pNamespace);};
  -	static AxisChar* AXISCALL s_GetAttributeAsString(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsDecimal(pName, pNamespace);};
  +    static AxisChar* AXISCALL s_GetAttributeAsString(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsString(pName, pNamespace);};
  -    static AxisChar* AXISCALL s_GetAttributeAsAnyURI(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsString(pName, pNamespace);};
  +    static AxisChar* AXISCALL s_GetAttributeAsAnyURI(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsAnyURI(pName, pNamespace);};
  -    static AxisChar* AXISCALL s_GetAttributeAsQName(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsAnyURI(pName, pNamespace);};
  +    static AxisChar* AXISCALL s_GetAttributeAsQName(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsQName(pName, pNamespace);};
  -	static xsd__hexBinary AXISCALL s_GetAttributeAsHexBinary(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsQName(pName, pNamespace);};
  +    static xsd__hexBinary AXISCALL s_GetAttributeAsHexBinary(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsHexBinary(pName, pNamespace);};
  -	static xsd__base64Binary AXISCALL s_GetAttributeAsBase64Binary(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsHexBinary(pName, pNamespace);};
  +    static xsd__base64Binary AXISCALL s_GetAttributeAsBase64Binary(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsBase64Binary(pName, 
  -		pNamespace);};
  -    static struct tm AXISCALL s_GetAttributeAsDateTime(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsBase64Binary(pName,
  +        pNamespace);};
  +    static struct tm AXISCALL s_GetAttributeAsDateTime(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsDateTime(pName, pNamespace);};
  -    static struct tm AXISCALL s_GetAttributeAsDate(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsDateTime(pName, pNamespace);};
  +    static struct tm AXISCALL s_GetAttributeAsDate(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsDate(pName, pNamespace);};
  -    static struct tm AXISCALL s_GetAttributeAsTime(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsDate(pName, pNamespace);};
  +    static struct tm AXISCALL s_GetAttributeAsTime(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsTime(pName, pNamespace);};
  -    static long AXISCALL s_GetAttributeAsDuration(void* pObj, 
  +    { return ((CallBase*)pObj)->getAttributeAsTime(pName, pNamespace);};
  +    static long AXISCALL s_GetAttributeAsDuration(void* pObj,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{ return ((CallBase*)pObj)->getAttributeAsDuration(pName, pNamespace);};
  +    { return ((CallBase*)pObj)->getAttributeAsDuration(pName, pNamespace);};
   
  -	static Axis_Array AXISCALL s_GetCmplxArray(void* pObj, void* pDZFunct, 
  -        void* pCreFunct, void* pDelFunct, void* pSizeFunct, 
  +    static Axis_Array AXISCALL s_GetCmplxArray(void* pObj, void* pDZFunct,
  +        void* pCreFunct, void* pDelFunct, void* pSizeFunct,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{return ((CallBase*)pObj)->getCmplxArray(pDZFunct, pCreFunct, pDelFunct,
  -		pSizeFunct, pName, pNamespace);};
  -	static Axis_Array AXISCALL s_GetBasicArray(void* pObj, XSDTYPE nType, 
  +    {return ((CallBase*)pObj)->getCmplxArray(pDZFunct, pCreFunct, pDelFunct,
  +        pSizeFunct, pName, pNamespace);};
  +    static Axis_Array AXISCALL s_GetBasicArray(void* pObj, XSDTYPE nType,
           const AxisChar* pName, const AxisChar* pNamespace)
  -	{return ((CallBase*)pObj)->getBasicArray(nType, pName, pNamespace);};
  -	static void* AXISCALL s_GetCmplxObject(void* pObj, void* pDZFunct, 
  -        void* pCreFunct, void* pDelFunct, const AxisChar* pName, 
  +    {return ((CallBase*)pObj)->getBasicArray(nType, pName, pNamespace);};
  +    static void* AXISCALL s_GetCmplxObject(void* pObj, void* pDZFunct,
  +        void* pCreFunct, void* pDelFunct, const AxisChar* pName,
           const AxisChar* pNamespace)
  -	{return ((CallBase*)pObj)->getCmplxObject(pDZFunct, pCreFunct, pDelFunct, 
  +    {return ((CallBase*)pObj)->getCmplxObject(pDZFunct, pCreFunct, pDelFunct,
           pName, pNamespace);};
   
  -	static int AXISCALL s_CheckMessage(void *pObj, const AxisChar* pName, 
  +    static int AXISCALL s_CheckMessage(void *pObj, const AxisChar* pName,
           const AxisChar* pNamespace)
  -	{return ((CallBase*)pObj)->checkMessage(pName, pNamespace);};
  +    {return ((CallBase*)pObj)->checkMessage(pName, pNamespace);};
   
  -	static int AXISCALL s_CheckFault(void *pObj, const AxisChar* pName, 
  +    static int AXISCALL s_CheckFault(void *pObj, const AxisChar* pName,
           const AxisChar* pNamespace)
  -	{return ((CallBase*)pObj)->checkFault(pName, pNamespace);};
  -	
  -	/* Minimal error check */
  -	static int AXISCALL s_GetStatus(void *pObj)
  -	{return ((CallBase*)pObj)->getStatus();};
  +    {return ((CallBase*)pObj)->checkFault(pName, pNamespace);};
  +
  +    /* Minimal error check */
  +    static int AXISCALL s_GetStatus(void *pObj)
  +    {return ((CallBase*)pObj)->getStatus();};
   
  -	static AnyType* AXISCALL s_GetAnyObject(void *pObj)
  -	{return ((CallBase*)pObj)->getAnyObject();};
  +    static AnyType* AXISCALL s_GetAnyObject(void *pObj)
  +    {return ((CallBase*)pObj)->getAnyObject();};
   
       static int AXISCALL s_AddAnyObject(void *pObj, AnyType* pAnyObject)
  -	{return ((CallBase*)pObj)->addAnyObject(pAnyObject);};
  +    {return ((CallBase*)pObj)->addAnyObject(pAnyObject);};
   
  -    static const AxisChar* AXISCALL s_GetNamespacePrefix(void *pObj, 
  +    static const AxisChar* AXISCALL s_GetNamespacePrefix(void *pObj,
           const AxisChar* pNamespace)
       {return ((CallBase*)pObj)->getNamespacePrefix(pNamespace);};
   
  -	static HeaderBlock_C AXISCALL s_CreateHeaderBlock(void *pObj, 
  +    static HeaderBlock_C AXISCALL s_CreateHeaderBlock(void *pObj,
           AxisChar *pachLocalName, AxisChar *pachUri);
   
       /* and populate ms_VFtable with corresponding entry */
  -	static void s_Initialize();
  +    static void s_Initialize();
   };
   
   /* A separate call class object should be used by each thread */
   class STORAGE_CLASS_INFO Call : public CallBase
   {
   public:
  -	Call();
  -	virtual ~Call();
  -	void AXISCALL setSOAPVersion(SOAP_VERSION version);
  -	int AXISCALL setTransportProperty(AXIS_TRANSPORT_INFORMATION_TYPE type,
  +    Call();
  +    virtual ~Call();
  +    void AXISCALL setSOAPVersion(SOAP_VERSION version);
  +    int AXISCALL setTransportProperty(AXIS_TRANSPORT_INFORMATION_TYPE type,
           const char* value);
  -	int AXISCALL setProtocol(AXIS_PROTOCOL_TYPE protocol);
  -	int AXISCALL unInitialize();
  -	int AXISCALL initialize(PROVIDERTYPE nStyle, int secure);
  -	int AXISCALL invoke();
  +    int AXISCALL setProtocol(AXIS_PROTOCOL_TYPE protocol);
  +    int AXISCALL unInitialize();
  +    int AXISCALL initialize(PROVIDERTYPE nStyle, int secure);
  +    int AXISCALL invoke();
   
  -	/* Method for adding complex parameters */
  -	void AXISCALL addCmplxParameter(void* pObject, void* pSZFunct, 
  +    /* Method for adding complex parameters */
  +    void AXISCALL addCmplxParameter(void* pObject, void* pSZFunct,
           void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace);
  -	/* Method for adding complex type array parameters */
  -	void AXISCALL addCmplxArrayParameter(Axis_Array* pArray, void* pSZFunct, 
  -        void* pDelFunct, void* pSizeFunct, const AxisChar* pName, 
  +    /* Method for adding complex type array parameters */
  +    void AXISCALL addCmplxArrayParameter(Axis_Array* pArray, void* pSZFunct,
  +        void* pDelFunct, void* pSizeFunct, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	/* Method for adding basic type array parameters */
  -	void AXISCALL addBasicArrayParameter(Axis_Array* pArray, XSDTYPE nType, 
  +    /* Method for adding basic type array parameters */
  +    void AXISCALL addBasicArrayParameter(Axis_Array* pArray, XSDTYPE nType,
           const AxisChar* pName);
  -	/* Method for adding parameters of basic types */
  -	void AXISCALL addParameter(void* pValue,const char* pchName, 
  +    /* Method for adding parameters of basic types */
  +    void AXISCALL addParameter(void* pValue,const char* pchName,
           XSDTYPE nType);
   
  -	/* Method that set the remote method name */
  -	void AXISCALL setOperation(const char* pchOperation, 
  +    /* Method that set the remote method name */
  +    void AXISCALL setOperation(const char* pchOperation,
           const char* pchNamespace);
  -	int AXISCALL setEndpointURI(const char* pchEndpointURI);
  +    int AXISCALL setEndpointURI(const char* pchEndpointURI);
   public:
  -	IHeaderBlock* AXISCALL createHeaderBlock(AxisChar *pachLocalName, 
  +    IHeaderBlock* AXISCALL createHeaderBlock(AxisChar *pachLocalName,
           AxisChar *pachUri);
  -	IHeaderBlock* createHeaderBlock();
  -	int setSoapHeader(SoapHeader *pSoapHeader);
  -	/* Methods used by stubs to get a deserialized value of XML element 
  -     * as basic types 
  +    IHeaderBlock* createHeaderBlock();
  +    int setSoapHeader(SoapHeader *pSoapHeader);
  +    /* Methods used by stubs to get a deserialized value of XML element
  +     * as basic types
        */
  -	int AXISCALL getElementAsInt(const AxisChar* pName, 
  +    int AXISCALL getElementAsInt(const AxisChar* pName,
           const AxisChar* pNamespace);
           int AXISCALL getFaultDetail(char** ppcDetail);
  -	xsd__boolean AXISCALL getElementAsBoolean(const AxisChar* pName, 
  +    xsd__boolean AXISCALL getElementAsBoolean(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned int AXISCALL getElementAsUnsignedInt(const AxisChar* pName, 
  +    unsigned int AXISCALL getElementAsUnsignedInt(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    short AXISCALL getElementAsShort(const AxisChar* pName, 
  +    short AXISCALL getElementAsShort(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned short AXISCALL getElementAsUnsignedShort(const AxisChar* pName, 
  +    unsigned short AXISCALL getElementAsUnsignedShort(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    char AXISCALL getElementAsByte(const AxisChar* pName, 
  +    char AXISCALL getElementAsByte(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned char AXISCALL getElementAsUnsignedByte(const AxisChar* pName, 
  +    unsigned char AXISCALL getElementAsUnsignedByte(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    long AXISCALL getElementAsLong(const AxisChar* pName, 
  +    long AXISCALL getElementAsLong(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    long AXISCALL getElementAsInteger(const AxisChar* pName, 
  +    long AXISCALL getElementAsInteger(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned long AXISCALL getElementAsUnsignedLong(const AxisChar* pName, 
  +    unsigned long AXISCALL getElementAsUnsignedLong(const AxisChar* pName,
           const AxisChar* pNamespace);
  -	float AXISCALL getElementAsFloat(const AxisChar* pName, 
  +    float AXISCALL getElementAsFloat(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    double AXISCALL getElementAsDouble(const AxisChar* pName, 
  +    double AXISCALL getElementAsDouble(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    double AXISCALL getElementAsDecimal(const AxisChar* pName, 
  +    double AXISCALL getElementAsDecimal(const AxisChar* pName,
           const AxisChar* pNamespace);
  -	AxisChar* AXISCALL getElementAsString(const AxisChar* pName, 
  +    AxisChar* AXISCALL getElementAsString(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    AxisChar* AXISCALL getElementAsAnyURI(const AxisChar* pName, 
  +    AxisChar* AXISCALL getElementAsAnyURI(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    AxisChar* AXISCALL getElementAsQName(const AxisChar* pName, 
  +    AxisChar* AXISCALL getElementAsQName(const AxisChar* pName,
           const AxisChar* pNamespace);
  -	xsd__hexBinary AXISCALL getElementAsHexBinary(const AxisChar* pName, 
  +    xsd__hexBinary AXISCALL getElementAsHexBinary(const AxisChar* pName,
           const AxisChar* pNamespace);
  -	xsd__base64Binary AXISCALL getElementAsBase64Binary(const AxisChar* pName, 
  +    xsd__base64Binary AXISCALL getElementAsBase64Binary(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    struct tm AXISCALL getElementAsDateTime(const AxisChar* pName, 
  +    struct tm AXISCALL getElementAsDateTime(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    struct tm AXISCALL getElementAsDate(const AxisChar* pName, 
  +    struct tm AXISCALL getElementAsDate(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    struct tm AXISCALL getElementAsTime(const AxisChar* pName, 
  +    struct tm AXISCALL getElementAsTime(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    long AXISCALL getElementAsDuration(const AxisChar* pName, 
  +    long AXISCALL getElementAsDuration(const AxisChar* pName,
           const AxisChar* pNamespace);
   
  -	/* Methods used by stubs to get a deserialized value of a XML attribute 
  -     * as basic types 
  +    /* Methods used by stubs to get a deserialized value of a XML attribute
  +     * as basic types
        */
  -	int AXISCALL getAttributeAsInt(const AxisChar* pName, 
  +    int AXISCALL getAttributeAsInt(const AxisChar* pName,
           const AxisChar* pNamespace);
  -	xsd__boolean AXISCALL getAttributeAsBoolean(const AxisChar* pName, 
  +    xsd__boolean AXISCALL getAttributeAsBoolean(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned int AXISCALL getAttributeAsUnsignedInt(const AxisChar* pName, 
  +    unsigned int AXISCALL getAttributeAsUnsignedInt(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    short AXISCALL getAttributeAsShort(const AxisChar* pName, 
  +    short AXISCALL getAttributeAsShort(const AxisChar* pName,
           const AxisChar* pNamespace);
       unsigned short AXISCALL getAttributeAsUnsignedShort(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    char AXISCALL getAttributeAsByte(const AxisChar* pName, 
  +    char AXISCALL getAttributeAsByte(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned char AXISCALL getAttributeAsUnsignedByte(const AxisChar* pName, 
  +    unsigned char AXISCALL getAttributeAsUnsignedByte(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    long AXISCALL getAttributeAsLong(const AxisChar* pName, 
  +    long AXISCALL getAttributeAsLong(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    long AXISCALL getAttributeAsInteger(const AxisChar* pName, 
  +    long AXISCALL getAttributeAsInteger(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    unsigned long AXISCALL getAttributeAsUnsignedLong(const AxisChar* pName, 
  +    unsigned long AXISCALL getAttributeAsUnsignedLong(const AxisChar* pName,
           const AxisChar* pNamespace);
  -	float AXISCALL getAttributeAsFloat(const AxisChar* pName, 
  +    float AXISCALL getAttributeAsFloat(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    double AXISCALL getAttributeAsDouble(const AxisChar* pName, 
  +    double AXISCALL getAttributeAsDouble(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    double AXISCALL getAttributeAsDecimal(const AxisChar* pName, 
  +    double AXISCALL getAttributeAsDecimal(const AxisChar* pName,
           const AxisChar* pNamespace);
  -	AxisChar* AXISCALL getAttributeAsString(const AxisChar* pName, 
  +    AxisChar* AXISCALL getAttributeAsString(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    AxisChar* AXISCALL getAttributeAsAnyURI(const AxisChar* pName, 
  +    AxisChar* AXISCALL getAttributeAsAnyURI(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    AxisChar* AXISCALL getAttributeAsQName(const AxisChar* pName, 
  +    AxisChar* AXISCALL getAttributeAsQName(const AxisChar* pName,
           const AxisChar* pNamespace);
  -	xsd__hexBinary AXISCALL getAttributeAsHexBinary(const AxisChar* pName, 
  +    xsd__hexBinary AXISCALL getAttributeAsHexBinary(const AxisChar* pName,
           const AxisChar* pNamespace);
  -	xsd__base64Binary AXISCALL getAttributeAsBase64Binary(const AxisChar* 
  +    xsd__base64Binary AXISCALL getAttributeAsBase64Binary(const AxisChar*
           pName, const AxisChar* pNamespace);
  -    struct tm AXISCALL getAttributeAsDateTime(const AxisChar* pName, 
  +    struct tm AXISCALL getAttributeAsDateTime(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    struct tm AXISCALL getAttributeAsDate(const AxisChar* pName, 
  +    struct tm AXISCALL getAttributeAsDate(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    struct tm AXISCALL getAttributeAsTime(const AxisChar* pName, 
  +    struct tm AXISCALL getAttributeAsTime(const AxisChar* pName,
           const AxisChar* pNamespace);
  -    long AXISCALL getAttributeAsDuration(const AxisChar* pName, 
  +    long AXISCALL getAttributeAsDuration(const AxisChar* pName,
           const AxisChar* pNamespace);
   
  -	/* Method used by stubs to get a deserialized value of complex types */
  -	void* AXISCALL getCmplxObject(void* pDZFunct, void* pCreFunct, 
  +    /* Method used by stubs to get a deserialized value of complex types */
  +    void* AXISCALL getCmplxObject(void* pDZFunct, void* pCreFunct,
           void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace);
  -	/* Method used by stubs to get a deserialized Array of complex types */
  -	Axis_Array AXISCALL getCmplxArray(void* pDZFunct, void* pCreFunct, 
  -        void* pDelFunct, void* pSizeFunct, const AxisChar* pName, 
  +    /* Method used by stubs to get a deserialized Array of complex types */
  +    Axis_Array AXISCALL getCmplxArray(void* pDZFunct, void* pCreFunct,
  +        void* pDelFunct, void* pSizeFunct, const AxisChar* pName,
           const AxisChar* pNamespace);
  -	/* Method used by stubs to get a deserialized Array of basic types */
  -	Axis_Array AXISCALL getBasicArray(XSDTYPE nType, const AxisChar* pName, 
  +    /* Method used by stubs to get a deserialized Array of basic types */
  +    Axis_Array AXISCALL getBasicArray(XSDTYPE nType, const AxisChar* pName,
           const AxisChar* pNamespace);
   
  -	int AXISCALL checkMessage(const AxisChar* pName, 
  +    int AXISCALL checkMessage(const AxisChar* pName,
           const AxisChar* pNamespace);
  -  
  -	int AXISCALL checkFault(const AxisChar* pName, 
  +
  +    int AXISCALL checkFault(const AxisChar* pName,
           const AxisChar* pNamespace);
   
  -	int AXISCALL getStatus();
  -	
  -	SOAPTransport* getTransport() { return m_pTransport; }
  -	SoapSerializer* getSOAPSerializer() { return (SoapSerializer*)m_pIWSSZ; }
  -	
  +    int AXISCALL getStatus();
  +
  +    SOAPTransport* getTransport() { return m_pTransport; }
  +    SoapSerializer* getSOAPSerializer() { return (SoapSerializer*)m_pIWSSZ; }
  +
     /**
       * Set proxy server and port for transport.
       *
       * @param pcProxyHost Host name of proxy server
       * @param uiProxyPort Port of proxy server
       */
  -    void setProxy(const char* pcProxyHost, unsigned int uiProxyPort); 
  +    void setProxy(const char* pcProxyHost, unsigned int uiProxyPort);
   
  -	AnyType* AXISCALL getAnyObject();
  -	int AXISCALL addAnyObject(AnyType* pAnyObject);
  +    AnyType* AXISCALL getAnyObject();
  +    int AXISCALL addAnyObject(AnyType* pAnyObject);
       const AxisChar* AXISCALL getNamespacePrefix(const AxisChar* pNamespace);
  -		
  +
   private:
  -	int openConnection(int secure);
  -	void closeConnection();
  -	int makeArray();
  +    int openConnection(int secure);
  +    void closeConnection();
  +    int makeArray();
   
   private:
  -	ClientAxisEngine* m_pAxisEngine;
  -	/* 
  -	   Following are pointers to relevant objects of the ClientAxisEngine
  -	   instance. So they do not belong to this object and are not created 
  -       or deleted 
  -	 */
  -	MessageData* m_pMsgData;
  -	IHandlerSoapSerializer* m_pIWSSZ;
  -	IHandlerSoapDeSerializer* m_pIWSDZ;
  -	const char* m_pcEndPointUri;
  -	AXIS_PROTOCOL_TYPE m_nTransportType;
  -	/*
  -	   Transport object
  -	 */
  -	SOAPTransport* m_pTransport;
  -	
  -	/* Minimal error check */
  -	int m_nStatus;
  +    ClientAxisEngine* m_pAxisEngine;
  +    /*
  +       Following are pointers to relevant objects of the ClientAxisEngine
  +       instance. So they do not belong to this object and are not created
  +       or deleted
  +     */
  +    MessageData* m_pMsgData;
  +    IHandlerSoapSerializer* m_pIWSSZ;
  +    IHandlerSoapDeSerializer* m_pIWSDZ;
  +    const char* m_pcEndPointUri;
  +    AXIS_PROTOCOL_TYPE m_nTransportType;
  +    /*
  +       Transport object
  +     */
  +    SOAPTransport* m_pTransport;
  +
  +    /* Minimal error check */
  +    int m_nStatus;
     /**
       * Proxy server name.
       */
  
  
  
  1.13      +6 -1      ws-axis/c/include/axis/server/Attribute.h
  
  Index: Attribute.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/Attribute.h,v
  retrieving revision 1.12
  retrieving revision 1.13
  diff -u -r1.12 -r1.13
  --- Attribute.h	14 Jun 2004 10:20:25 -0000	1.12
  +++ Attribute.h	17 Jun 2004 08:42:50 -0000	1.13
  @@ -14,7 +14,12 @@
    *   limitations under the License.
    */
   
  -
  + /**
  + * @file Attribute.h
  + *
  + *
  + */
  + 
   #if !defined(_ATTRIBUTE_H____OF_AXIS_INCLUDED_)
   #define _ATTRIBUTE_H____OF_AXIS_INCLUDED_
   
  
  
  
  1.14      +6 -0      ws-axis/c/include/axis/server/AxisConfig.h
  
  Index: AxisConfig.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/AxisConfig.h,v
  retrieving revision 1.13
  retrieving revision 1.14
  diff -u -r1.13 -r1.14
  --- AxisConfig.h	14 Jun 2004 07:33:57 -0000	1.13
  +++ AxisConfig.h	17 Jun 2004 08:42:50 -0000	1.14
  @@ -13,7 +13,13 @@
    *   See the License for the specific language governing permissions and
    *   limitations under the License.
    *
  + */
  +
  + /**
  + * @file AxisConfig.h
  + *
    * @author Sanjaya Singharage (sanjayas@opensource.lk, sanjayas@jkcsworld.com)
  + *
    */
    
   #if !defined(__AXIS_AXISCONFIG_H_OF_AXIS_INCLUDED__)
  
  
  
  1.10      +7 -0      ws-axis/c/include/axis/server/AxisEngine.h
  
  Index: AxisEngine.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/AxisEngine.h,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- AxisEngine.h	12 May 2004 07:36:46 -0000	1.9
  +++ AxisEngine.h	17 Jun 2004 08:42:50 -0000	1.10
  @@ -14,6 +14,13 @@
    *   limitations under the License.
    */
   
  +/**
  + * @file AxisEngine.h
  + *
  + *   @author Susantha Kumara (skumara@virtusa.com)
  + *
  + */
  + 
   #ifdef WIN32
   #pragma warning (disable : 4786)
   #endif
  
  
  
  1.19      +7 -1      ws-axis/c/include/axis/server/AxisException.h
  
  Index: AxisException.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/AxisException.h,v
  retrieving revision 1.18
  retrieving revision 1.19
  diff -u -r1.18 -r1.19
  --- AxisException.h	15 Jun 2004 16:19:54 -0000	1.18
  +++ AxisException.h	17 Jun 2004 08:42:50 -0000	1.19
  @@ -14,7 +14,13 @@
    *   limitations under the License.
    *
    *
  - *   @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
  + *
  + */
  +
  +/**
  + * @file AxisException.h
  + *
  + * @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
    *
    */
    
  
  
  
  1.5       +7 -0      ws-axis/c/include/axis/server/AxisFile.h
  
  Index: AxisFile.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/AxisFile.h,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- AxisFile.h	4 Jun 2004 04:59:39 -0000	1.4
  +++ AxisFile.h	17 Jun 2004 08:42:50 -0000	1.5
  @@ -13,6 +13,13 @@
    *   See the License for the specific language governing permissions and
    *   limitations under the License.
    */
  +
  +/**
  + * @file AxisFile.h
  + *
  + * @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
  + *
  + */
    
   #if !defined(__AXIS_AXISFILE_H_OF_AXIS_INCLUDED__)
   #define __AXIS_AXISFILE_H_OF_AXIS_INCLUDED__
  
  
  
  1.2       +5 -1      ws-axis/c/include/axis/server/AxisMessage.h
  
  Index: AxisMessage.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/AxisMessage.h,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- AxisMessage.h	24 May 2004 05:46:27 -0000	1.1
  +++ AxisMessage.h	17 Jun 2004 08:42:50 -0000	1.2
  @@ -13,8 +13,12 @@
    *   See the License for the specific language governing permissions and
    *   limitations under the License.
    *
  + */
  +
  +/**
  + * @file AxisMessage.h
    *
  - *   @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
  + * @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
    *
    */
    
  
  
  
  1.14      +8 -1      ws-axis/c/include/axis/server/AxisTime.h
  
  Index: AxisTime.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/AxisTime.h,v
  retrieving revision 1.13
  retrieving revision 1.14
  diff -u -r1.13 -r1.14
  --- AxisTime.h	25 May 2004 03:47:33 -0000	1.13
  +++ AxisTime.h	17 Jun 2004 08:42:50 -0000	1.14
  @@ -13,7 +13,14 @@
    *   See the License for the specific language governing permissions and
    *   limitations under the License.
    */
  - 
  +
  +/**
  + * @file AxisTime.h
  + *
  + * @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
  + *
  + */
  +  
   #ifndef __AXISTIME_H_OF_AXIS_INCLUDED_
   #define __AXISTIME_H_OF_AXIS_INCLUDED_
   
  
  
  
  1.17      +7 -0      ws-axis/c/include/axis/server/AxisTrace.h
  
  Index: AxisTrace.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/AxisTrace.h,v
  retrieving revision 1.16
  retrieving revision 1.17
  diff -u -r1.16 -r1.17
  --- AxisTrace.h	24 May 2004 05:44:19 -0000	1.16
  +++ AxisTrace.h	17 Jun 2004 08:42:50 -0000	1.17
  @@ -14,6 +14,13 @@
    *   limitations under the License.
    */ 
   
  +/**
  + * @file AxisTrace.h
  + *
  + * @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
  + *
  + */
  +  
   #ifndef __AXISLOG_H_INCLUDED_
   #define __AXISLOG_H_INCLUDED_
   
  
  
  
  1.11      +152 -145  ws-axis/c/include/axis/server/BasicHandler.h
  
  Index: BasicHandler.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/BasicHandler.h,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -r1.10 -r1.11
  --- BasicHandler.h	14 Jun 2004 07:17:19 -0000	1.10
  +++ BasicHandler.h	17 Jun 2004 08:42:50 -0000	1.11
  @@ -16,6 +16,13 @@
    *
    */
   
  +/**
  + * @file BasicHandler.h
  + *
  + * @author Susantha Kumara (skumara@virtusa.com)
  + * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com) *
  + */
  +  
   #if !defined(_BASICHANDLER_H__OF_AXIS_INCLUDED_)
   #define _BASICHANDLER_H__OF_AXIS_INCLUDED_
   
  @@ -46,12 +53,12 @@
   /**
     * @class HandlerBase
     * @brief interface for the Handlers. This is the base class for:
  -  *		- Handler 
  -  *		- WrapperClassHandler
  +  *        - Handler 
  +  *        - WrapperClassHandler
     * In the Axis Architecture there are different types of Handlers :
  -  *		- NORMAL_HANDLER : A Handler which is used to process SOAP Headers.
  -  *		- WEBSERVICE_HANDLER : A web service is also considered as a Handler.
  -  *		- CHAIN_HANDLER : Handler Chains are also derived from Handler.
  +  *        - NORMAL_HANDLER : A Handler which is used to process SOAP Headers.
  +  *        - WEBSERVICE_HANDLER : A web service is also considered as a Handler.
  +  *        - CHAIN_HANDLER : Handler Chains are also derived from Handler.
     * Each of these handlers will inherit from this HandlerBase which serves as
     * the base point for all the different types of Handlers.
     *
  @@ -65,161 +72,161 @@
    * Added doxygen comments to help autobuild API docs
    */
   
  -class HandlerBase  
  +class HandlerBase
   {
   public:
  -	/**
  -	  * Constructor.
  -	  */
  +    /**
  +      * Constructor.
  +      */
       HandlerBase(){};
   
  -	/**
  -	  * Destructor.
  -	  */
  +    /**
  +      * Destructor.
  +      */
       virtual ~HandlerBase(){};
   
  -	/**
  -	  * The invoke method is automatically called by the Axis Engine when it 
  -	  * needs to execute a Handler. The main task of the handler which a 
  -	  * Handler writer expects the Handler to be performed needs to be written
  -	  * within the invoke method of the Handler.
  -	  *
  -	  * A example code segment within a invoke method which is written to 
  -	  * process a SOAP Header is as following:
  -	  * <PRE>
  -	  * int ESHHandler::invoke(void *pvIMsg)
  -	  * {
  -	  * IMessageData *pIMsg = (IMessageData*) pvIMsg;
  -	  *	AxisChar* pachTemp;
  -	  *	if(pIMsg->isPastPivot()) {
  -	  *		//this is a response
  -	  *
  -	  *		IHandlerSoapSerializer* pISZ;
  -	  *		pIMsg->getSoapSerializer(&pISZ);
  -	  *
  -	  *		IHeaderBlock* pIHeaderBlock= pISZ->createHeaderBlock();
  -	  *
  -	  *		pIHeaderBlock->setLocalName("echoMeStringResponse");
  -	  *		pIHeaderBlock->setUri("http://soapinterop.org/echoheader/");
  -	  *
  -	  *		pachTemp = "EchoStringHeaderHandlerPr1.id";
  -      *
  -	  *		const AxisChar* pachHeaderVal = pIMsg->getProperty(pachTemp);
  -	  *		printf("in the ESHHandler::Invoke : %s\n",pachHeaderVal);
  -	  *
  -	  *		BasicNode* pBasicNode = pIHeaderBlock->createChild(CHARACTER_NODE);
  -	  *		pBasicNode->setValue(pachHeaderVal);
  -	  *		
  -	  *		pIHeaderBlock->addChild(pBasicNode);
  -	  *
  -	  * } else {
  -	  *		//this is a request
  -	  *		
  -	  *		IHandlerSoapDeSerializer* pIHandlerSoapDeSerializer;
  -	  *		pIMsg->getSoapDeSerializer(&pIHandlerSoapDeSerializer);
  -	  *
  -	  *		IHeaderBlock* pIHeaderBlock= pIHandlerSoapDeSerializer->getHeaderBlock("echoMeString", "http://soapinterop.org/echoheader/");
  -	  *		
  -	  *		if (pIHeaderBlock != NULL) {
  -	  *
  -	  *			const BasicNode* pBasicNode= pIHeaderBlock->getFirstChild();
  -	  *						
  -	  *			const AxisChar* pachHeaderValue;
  -	  *
  -	  *			if (pBasicNode != NULL) 
  -	  *			{
  -	  *				if((pBasicNode->getNodeType()) == CHARACTER_NODE) {
  -	  *					pachHeaderValue= pBasicNode->getValue();
  -	  *				} else {
  -	  *					pachHeaderValue = "This was not the expected value Ros";
  -	  *				}
  -	  *			} else 
  -	  *			{
  -	  *				pachHeaderValue = "pBascNode is NULL";
  -	  *			}
  -	  *
  -	  *			AxisChar* pachTmpValue = (AxisChar*) malloc(strlen(pachHeaderValue) + 4);
  -	  *			strcpy(pachTmpValue, pachHeaderValue);
  -	  *
  -	  *			pachTemp = "EchoStringHeaderHandlerPr1.id";
  -	  *			pIMsg->setProperty(pachTemp, pachTmpValue);
  -	  *
  -	  *			free(pachTmpValue);
  -	  *			
  -	  *			
  -	  *		} else {
  -	  *			//do some thing
  -	  *		}
  -	  *
  -	  *	}
  -	  *
  -	  *	return AXIS_SUCCESS;
  -	  *	}
  -	  * </PRE>
  -	  * 
  -	  * In case of a Web Service Handler the invoke method should do what is 
  -	  * required by a web service invoke method, which is different from the
  -	  * above shown example.
  -	  *
  -	  * @param pMsg The MessageData object pointer. This MessageData object is
  -	  * passed to every handler when serving to a client request. The handler
  -	  * writer can get access to objects such as:
  -	  *		- IHandlerSoapDeSerializer
  -	  *		- IHandlerSoapSerializer
  -	  *		- The properties/data/info which are set by other handlers
  -	  *		- The properties/data/info which is set by the Client Stub in case
  -	  *		  the Handler is a Client side Handler.
  -	  *												etc.
  -	  * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
  -	  */
  +    /**
  +      * The invoke method is automatically called by the Axis Engine when it
  +      * needs to execute a Handler. The main task of the handler which a
  +      * Handler writer expects the Handler to be performed needs to be written
  +      * within the invoke method of the Handler.
  +      *
  +      * A example code segment within a invoke method which is written to
  +      * process a SOAP Header is as following:
  +      * <PRE>
  +      * int ESHHandler::invoke(void *pvIMsg)
  +      * {
  +      * IMessageData *pIMsg = (IMessageData*) pvIMsg;
  +      *    AxisChar* pachTemp;
  +      *    if(pIMsg->isPastPivot()) {
  +      *        //this is a response
  +      *
  +      *        IHandlerSoapSerializer* pISZ;
  +      *        pIMsg->getSoapSerializer(&pISZ);
  +      *
  +      *        IHeaderBlock* pIHeaderBlock= pISZ->createHeaderBlock();
  +      *
  +      *        pIHeaderBlock->setLocalName("echoMeStringResponse");
  +      *        pIHeaderBlock->setUri("http://soapinterop.org/echoheader/");
  +      *
  +      *        pachTemp = "EchoStringHeaderHandlerPr1.id";
  +      *
  +      *        const AxisChar* pachHeaderVal = pIMsg->getProperty(pachTemp);
  +      *        printf("in the ESHHandler::Invoke : %s\n",pachHeaderVal);
  +      *
  +      *        BasicNode* pBasicNode = pIHeaderBlock->createChild(CHARACTER_NODE);
  +      *        pBasicNode->setValue(pachHeaderVal);
  +      *
  +      *        pIHeaderBlock->addChild(pBasicNode);
  +      *
  +      * } else {
  +      *        //this is a request
  +      *
  +      *        IHandlerSoapDeSerializer* pIHandlerSoapDeSerializer;
  +      *        pIMsg->getSoapDeSerializer(&pIHandlerSoapDeSerializer);
  +      *
  +      *        IHeaderBlock* pIHeaderBlock= pIHandlerSoapDeSerializer->getHeaderBlock("echoMeString", "http://soapinterop.org/echoheader/");
  +      *
  +      *        if (pIHeaderBlock != NULL) {
  +      *
  +      *            const BasicNode* pBasicNode= pIHeaderBlock->getFirstChild();
  +      *
  +      *            const AxisChar* pachHeaderValue;
  +      *
  +      *            if (pBasicNode != NULL)
  +      *            {
  +      *                if((pBasicNode->getNodeType()) == CHARACTER_NODE) {
  +      *                    pachHeaderValue= pBasicNode->getValue();
  +      *                } else {
  +      *                    pachHeaderValue = "This was not the expected value Ros";
  +      *                }
  +      *            } else
  +      *            {
  +      *                pachHeaderValue = "pBascNode is NULL";
  +      *            }
  +      *
  +      *            AxisChar* pachTmpValue = (AxisChar*) malloc(strlen(pachHeaderValue) + 4);
  +      *            strcpy(pachTmpValue, pachHeaderValue);
  +      *
  +      *            pachTemp = "EchoStringHeaderHandlerPr1.id";
  +      *            pIMsg->setProperty(pachTemp, pachTmpValue);
  +      *
  +      *            free(pachTmpValue);
  +      *
  +      *
  +      *        } else {
  +      *            //do some thing
  +      *        }
  +      *
  +      *    }
  +      *
  +      *    return AXIS_SUCCESS;
  +      *    }
  +      * </PRE>
  +      *
  +      * In case of a Web Service Handler the invoke method should do what is
  +      * required by a web service invoke method, which is different from the
  +      * above shown example.
  +      *
  +      * @param pMsg The MessageData object pointer. This MessageData object is
  +      * passed to every handler when serving to a client request. The handler
  +      * writer can get access to objects such as:
  +      *        - IHandlerSoapDeSerializer
  +      *        - IHandlerSoapSerializer
  +      *        - The properties/data/info which are set by other handlers
  +      *        - The properties/data/info which is set by the Client Stub in case
  +      *          the Handler is a Client side Handler.
  +      *                                                etc.
  +      * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
  +      */
       virtual int AXISCALL invoke(void* pMsg)=0;
   
  -	/**
  -	  * Called when ever a fault is occured within the handler. The tasks which
  -	  * needs to be persormed when ever an error occurs within a Handler has
  -	  * to be written within this method.
  -	  *
  +    /**
  +      * Called when ever a fault is occured within the handler. The tasks which
  +      * needs to be persormed when ever an error occurs within a Handler has
  +      * to be written within this method.
  +      *
         * @param mMsg The MessageData object pointer. This MessageData object is
  -	  * passed to every handler when serving to a client request. The handler
  -	  * writer can get access to objects such as:
  -	  *		- IHandlerSoapDeSerializer
  -	  *		- IHandlerSoapSerializer	
  -	  *								etc.
  -	  * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
  -	  */
  +      * passed to every handler when serving to a client request. The handler
  +      * writer can get access to objects such as:
  +      *        - IHandlerSoapDeSerializer
  +      *        - IHandlerSoapSerializer
  +      *                                etc.
  +      * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
  +      */
       virtual void AXISCALL onFault(void* mMsg)=0;
   
  -	/**
  -	  * The initialization tasks which needs to be performed within a Handler
  -	  * has to be written here. This method will be automatically called by the
  -	  * Axis Engine when it loads a handler.
  -	  *
  -	  * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
  -	  */
  +    /**
  +      * The initialization tasks which needs to be performed within a Handler
  +      * has to be written here. This method will be automatically called by the
  +      * Axis Engine when it loads a handler.
  +      *
  +      * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
  +      */
       virtual int AXISCALL init()=0;
   
  -	/**
  -	  * The finalization tasks which needs to be performed within a Handler
  -	  * has to be written here. This method will be automatically called by the
  -	  * Axis Engine when it unloads a handler.
  -	  *
  -	  * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
  -	  */
  +    /**
  +      * The finalization tasks which needs to be performed within a Handler
  +      * has to be written here. This method will be automatically called by the
  +      * Axis Engine when it unloads a handler.
  +      *
  +      * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
  +      */
       virtual int AXISCALL fini()=0;
   
  -	/**
  -	  * Gets and returns the type of the handler. The return value could be :
  -	  *		- NORMAL_HANDLER
  -	  *		- WEBSERVICE_HANDLER
  -	  *		- CHAIN_HANDLER
  -	  *
  -	  *	@return This returns the following depending on the actual Handler 
  -	  * type:
  -	  *		- NORMAL_HANDLER : In case of a normal Handler which is used to 
  -	  *						   process SOAP Headers.
  -	  *		- WEBSERVICE_HANDLER : In case of a Web Service.
  -	  *		- CHAIN_HANDLER : In case of a HandlerChain
  -	  */
  +    /**
  +      * Gets and returns the type of the handler. The return value could be :
  +      *        - NORMAL_HANDLER
  +      *        - WEBSERVICE_HANDLER
  +      *        - CHAIN_HANDLER
  +      *
  +      *    @return This returns the following depending on the actual Handler
  +      * type:
  +      *        - NORMAL_HANDLER : In case of a normal Handler which is used to
  +      *                           process SOAP Headers.
  +      *        - WEBSERVICE_HANDLER : In case of a Web Service.
  +      *        - CHAIN_HANDLER : In case of a HandlerChain
  +      */
       virtual int AXISCALL getType()=0;
   };
   #endif
  
  
  
  1.14      +6 -0      ws-axis/c/include/axis/server/BasicNode.h
  
  Index: BasicNode.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/BasicNode.h,v
  retrieving revision 1.13
  retrieving revision 1.14
  diff -u -r1.13 -r1.14
  --- BasicNode.h	14 Jun 2004 10:20:25 -0000	1.13
  +++ BasicNode.h	17 Jun 2004 08:42:50 -0000	1.14
  @@ -15,6 +15,12 @@
    */
   
   
  +/**
  + * @file BasicNode.h
  + *
  + * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com) *
  + */
  +  
   #if !defined(_BASICNODE_H____OF_AXIS_INCLUDED_)
   #define _BASICNODE_H____OF_AXIS_INCLUDED_
   
  
  
  
  1.8       +9 -0      ws-axis/c/include/axis/server/BasicTypeSerializer.h
  
  Index: BasicTypeSerializer.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/BasicTypeSerializer.h,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -r1.7 -r1.8
  --- BasicTypeSerializer.h	30 Apr 2004 05:38:30 -0000	1.7
  +++ BasicTypeSerializer.h	17 Jun 2004 08:42:50 -0000	1.8
  @@ -14,6 +14,15 @@
    *   limitations under the License.
    */
   
  +/**
  + * @file BasicTypeSerializer.h
  + *
  + * This file contains the BasicTypeSerializer class which has the functions
  + * that the Serializer uses to serialize all xsd basic types.
  + *
  + * @author Susantha Kumara (susantha@opensource.lk, skumara@virtusa.com)
  + */
  +  
   #if !defined(_BASICTYPESERIALIZER_H____OF_AXIS_INCLUDED_)
   #define _BASICTYPESERIALIZER_H____OF_AXIS_INCLUDED_
   
  
  
  
  1.15      +9 -0      ws-axis/c/include/axis/server/XMLParser.h
  
  Index: XMLParser.h
  ===================================================================
  RCS file: /home/cvs/ws-axis/c/include/axis/server/XMLParser.h,v
  retrieving revision 1.14
  retrieving revision 1.15
  diff -u -r1.14 -r1.15
  --- XMLParser.h	14 Jun 2004 13:59:17 -0000	1.14
  +++ XMLParser.h	17 Jun 2004 08:42:50 -0000	1.15
  @@ -14,6 +14,15 @@
    *   limitations under the License.
    */
   
  +/**
  + * @file XMLParser.h
  + *
  + * This file contains the API that any XML parser library for Axis should
  + * implement.
  + *
  + * @author Susantha Kumara (susantha@opensource.lk, skumara@virtusa.com)
  + */
  + 
   #include "AnyElement.h"
   #include "Packet.h"
   #include <axis/SOAPTransport.h>
  
  
  

Mime
View raw message