axis-java-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From whitl...@apache.org
Subject cvs commit: ws-axis/c/include/axis AxisException.hpp AxisUserAPI.hpp AxisWrapperAPI.hpp BasicHandler.hpp BasicNode.hpp GDefine.hpp Handler.hpp IHandlerSoapDeSerializer.hpp IHandlerSoapSerializer.hpp IHeaderBlock.hpp IMessageData.hpp IWrapperSoapDeSerializer.hpp IWrapperSoapSerializer.hpp SoapEnvVersions.hpp TypeMapping.hpp WSDDDefines.hpp
Date Tue, 23 Nov 2004 11:11:11 GMT
whitlock    2004/11/23 03:11:11

  Added:       c/include/axis AxisException.hpp AxisUserAPI.hpp
                        AxisWrapperAPI.hpp BasicHandler.hpp BasicNode.hpp
                        GDefine.hpp Handler.hpp
                        IHandlerSoapDeSerializer.hpp
                        IHandlerSoapSerializer.hpp IHeaderBlock.hpp
                        IMessageData.hpp IWrapperSoapDeSerializer.hpp
                        IWrapperSoapSerializer.hpp SoapEnvVersions.hpp
                        TypeMapping.hpp WSDDDefines.hpp
  Log:
  Move common header files from include/axis/server to include/axis
  
  Revision  Changes    Path
  1.1                  ws-axis/c/include/axis/AxisException.hpp
  
  Index: AxisException.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   *
   *
   *
   */
  
  /**
   * @file AxisException.h
   *
   * @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
   *
   */
   
  #ifndef __AXISEXCEPTION_H_OF_AXIS_INCLUDED_
  #define __AXISEXCEPTION_H_OF_AXIS_INCLUDED_
  
  #include <axis/server/GDefine.hpp>
  #include <string>
  #include <exception>
  #include <new>
  #include <typeinfo>
  #include <stdexcept>
  
  AXIS_CPP_NAMESPACE_START
  using namespace std;
  
  /*
   * The following enumeration is used to serve the Axis C++ codes for 
   * faults.
   */
  enum AXISC_EXCEPTIONS 
  {
      /* VersionMismatch faults */
  /*0*/    SOAP_VERSION_MISMATCH,
      
      /* MustUnderstand faults */
  /*1*/    SOAP_MUST_UNDERSTAND,
  
      /*The notation used for naming these exceptions is as follows
       *CLIENT at the beginning means when this interpreted as a soap fault
       *    it's fault code is CLIENT
       *SERVER at the beginning means when this interpreted as a soap fault
       *    it's fault code is SERVER
       *SOAP that comes next to CLIENT/SERVER means this is a soap releated
       *    exception
       *ENGINE that comes next to CLIENT/SERVER means this is a axisc++ engine
       *    related exception
       *WSDD that comes next to CLIENT/SERVER means this is a wsdd releated
       *    exception
       *TRANSPORT that comes next to CLIENT/SERVER means this is a transport releated
       *    exception
       *CONFIG that comes next to CLIENT/SERVER means this is a axisc++ configuration
       *    related exception
       */
       
      /* Client faults */
  /*2*/    CLIENT_SOAP_MESSAGE_INCOMPLETE,
  /*3*/    CLIENT_SOAP_SOAP_ACTION_EMTPY,
  /*4*/    CLIENT_SOAP_SOAP_CONTENT_ERROR,
  /*5*/    CLIENT_SOAP_NO_SOAP_METHOD,
  /*6*/    CLIENT_SOAP_CONTENT_NOT_SOAP,
  /*7*/    CLIENT_WSDD_SERVICE_NOT_FOUND,
  /*8*/    CLIENT_WSDD_METHOD_NOT_ALLOWED,
  /*9*/    CLIENT_WSDD_PARA_TYPE_MISMATCH,
  /*10*/    CLIENT_ENGINE_CLIENT_HANDLER_FAILED,
  			CLIENT_TRANSPORT_EXCEPTION,
  			CLIENT_TRANSPORT_OPEN_CONNECTION_FAILED,
  			CLIENT_TRANSPORT_TYPE_MISMATCH,
  			CLIENT_TRANSPORT_HAS_NO_SECURE_TRANSPORT_LAYER,
  
      /* Server faults */
  /*11*/    SERVER_ENGINE_EXCEPTION,
  /*12*/    SERVER_ENGINE_COULD_NOT_LOAD_SRV,
  /*13*/    SERVER_ENGINE_COULD_NOT_LOAD_HDL,
  /*14*/    SERVER_ENGINE_LOADING_TRANSPORT_FAILED,
  /*15*/    SERVER_ENGINE_LOADING_PARSER_FAILED,
  /*16*/    SERVER_ENGINE_HANDLER_FAILED,
  /*17*/    SERVER_ENGINE_WEBSERVICE_FAILED,
  /*18*/    SERVER_ENGINE_HANDLER_INIT_FAILED,
  /*19*/    SERVER_ENGINE_HANDLER_CREATION_FAILED,
  /*20*/    SERVER_ENGINE_LIBRARY_LOADING_FAILED,
  /*21*/    SERVER_ENGINE_HANDLER_NOT_LOADED,
  /*22*/    SERVER_ENGINE_HANDLER_BEING_USED,
  /*23*/    SERVER_ENGINE_GET_HANDLER_FAILED,
  /*24*/    SERVER_ENGINE_WRONG_HANDLER_TYPE,
  /*25*/    SERVER_CONFIG_EXCEPTION,
  /*26*/    SERVER_CONFIG_TRANSPORT_CONF_FAILED,
  /*27*/    SERVER_CONFIG_LIBRARY_PATH_EMPTY,
  /*28*/    SERVER_WSDD_FILE_NOT_FOUND,
  /*29*/    SERVER_WSDD_EXCEPTION,
  /*30*/    SERVER_WSDD_NO_HANDLERS_CONFIGURED,
  /*31*/    SERVER_SOAP_EXCEPTION,
  /*32*/    SERVER_TRANSPORT_EXCEPTION,
  /*33*/    SERVER_TRANSPORT_RECEPTION_EXCEPTION,
  /*34*/    SERVER_TRANSPORT_SENDING_EXCEPTION,
  /*35*/    SERVER_TRANSPORT_PROCESS_EXCEPTION,
  /*36*/    SERVER_TRANSPORT_UNKNOWN_HTTP_RESPONSE,
  /*37*/    SERVER_TRANSPORT_HTTP_EXCEPTION,
  /*38*/    SERVER_TRANSPORT_UNEXPECTED_STRING,
  /*39*/    SERVER_TRANSPORT_CHANNEL_INIT_ERROR,
  /*40*/    SERVER_TRANSPORT_SOCKET_CREATE_ERROR,
  /*41*/    SERVER_TRANSPORT_SOCKET_CONNECT_ERROR,
  /*42*/    SERVER_TRANSPORT_INVALID_SOCKET,
  /*43*/    SERVER_TRANSPORT_OUTPUT_STREAMING_ERROR,
  /*44*/    SERVER_TRANSPORT_INPUT_STREAMING_ERROR,
  /*45*/    SERVER_TRANSPORT_TIMEOUT_EXCEPTION,
  /*46*/    SERVER_TRANSPORT_TIMEOUT_EXPIRED,
  /*47*/    SERVER_TRANSPORT_BUFFER_EMPTY,
  /*48*/    SERVER_PARSE_BUFFER_EMPTY,
  /*49*/    SERVER_PARSE_PARSER_FAILED, 
  /*50*/    SERVER_PARSE_TRANSPORT_FAILED,
   
  /*51*/    SERVER_TEST_EXCEPTION,
  /*52*/    SERVER_UNKNOWN_ERROR,
      /*Following exceptions are not releated to soap faults
       */
  /*53*/    AXISC_SERVICE_THROWN_EXCEPTION,
  /*54*/    AXISC_UNKNOWN_ELEMENT_EXCEPTION,
  /*55*/    AXISC_NODE_VALUE_MISMATCH_EXCEPTION,
  /*56*/    AXISC_READ_CONF_EXCEPTION,
  
      /*
       * This FAULT_LAST is not used as a fault code, but instead is used 
       * internaly in the code. Developers should not use this as a fault 
       * code.
       */
  /*57*/    FAULT_LAST 
  };
  
  /**
   *   @class AxisException
   *   @brief Base class for Axis C++ exception hierarchy.
   *
   *   This will act as the base class for Axis C++ exception hierarchy. 
   *   This is class is derived from the std c++ exception class. Derived
   *   from this class are AxisConfigExceptin, AxisSoapExceptin, AxisWsddException,
   *   AxisEngineException, AxisTransportException and AxisParseException.
   *
   *   @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
   */
  class STORAGE_CLASS_INFO AxisException :public exception
  {
  
  public:
      /** No parameter constructor*/
      //AxisException(){};
  
      /** This can be used to throw an exception with the exception code
        * which is defined in the AxisException.h file, under AXISC_EXCEPTIONS
        * type. Axis C++ exception model heavily use this.
        *
        * @param Exception code which is defined in the AxisException.h file, 
        * under AXISC_EXCEPTIONS type.
        * 
        * @example throw AxisException(AXISC_NODE_VALUE_MISMATCH_EXCEPTION);
        */
      //AxisException(const int iExceptionCode);
  
      /** This can be used to throw an exception with exception code which is
        * is defined in the AxisException.h file, under AXISC_EXCEPTIONS type.
        * An additional description of the exception could be appended.
        *
        * @param Exception code which is defined in the AxisException.h file,
        *  under AXISC_EXCEPTIONS type.
        * @param A char pointer that will point to an exception message.
        *
        * @example throw AxisException(AXISC_NODE_VALUE_MISMATCH_EXCEPTION, 
              "Some additional exception info");
        */
      //AxisException(const int iExceptionCode, char* pcMessage);
  
      /** This can be used to throw an exception with another exception as a
        * parameter. One situation in which this can be used is when we catch
        * a standard exception like std::bad_alloc
        *
        * @param An exception class derived from std::exception
        *
        * @example throw AxisException(std::bad_alloc);
        */
      //AxisException(const exception* e);
  
      /** This accept two parameters, both an exception code an exception object
        * derived from std::exception
        *
        * @param An exception class derived from std::exception
        * @param An exception code
        */
      //AxisException(const exception* e, const int iExceptionCode);
      
      /** This accept an exception message
        *
        * @param An exception message
        */
      //AxisException(const char* pcMessage){m_sMessage = pcMessage;};
      
      /** Destructor */
      virtual ~AxisException() throw(){};
  
      /** This method is defined in std::exception. AxisException and derived
        * classes will override this to print exception messages
        */
      virtual const char* what() throw() = 0;
  
      /** This can be called to get the exception code which is passed
        * in the constructor. This returns -1 value when the 
        * constructor does not have a exception code parameter
        * 
        * @return the exception code if the construct have a exception code
        * int parameter. Else return -1.
        *
        * @return exception message
        */
      virtual const int getExceptionCode() = 0;
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif
  
  
  
  
  1.1                  ws-axis/c/include/axis/AxisUserAPI.hpp
  
  Index: AxisUserAPI.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   *
   */
  
  #if !defined(_AXISUSERAPI_H____OF_AXIS_INCLUDED_)
  #define _AXISUSERAPI_H____OF_AXIS_INCLUDED_
  
  #include <axis/server/GDefine.hpp>
  #include <time.h>
  #include <string.h>
  
  AXIS_CPP_NAMESPACE_START
  
   /**
    * @file AxisUserAPI.hpp
    * This file contains types defined in Axis C++. The mapping of basic xsd types
    * to the C language types.
    * @author Susantha Kumara (susantha@opensource.lk, skumara@virtusa.com)
    */
  
  /**
   * @typedef xsd__string
   * Axis C++ defined type for xml basic type string
   */
  typedef AxisChar * xsd__string;
  /**
   * @typedef xsd__integer
   * Axis C++ defined type for xml basic type integer
   */
  typedef int xsd__integer;
  /**
   * @typedef xsd__int
   * Axis C++ defined type for xml basic type int
   */
  typedef int xsd__int;
  /**
   * @typedef xsd__long
   * Axis C++ defined type for xml basic type long
   */
  //FJP v Added
  #ifdef WIN32
  typedef __int64 xsd__long;
  #else
  typedef long long xsd__long;
  #endif
  //FJP ^ Added
  /**
   * @typedef xsd__short
   * Axis C++ defined type for xml basic type short
   */
  typedef short xsd__short;
  /**
   * @typedef xsd__decimal
   * Axis C++ defined type for xml basic type decimal
   */
  typedef double xsd__decimal;
  /**
   * @typedef xsd__float
   * Axis C++ defined type for xml basic type float
   */
  typedef float xsd__float;
  /**
   * @typedef xsd__double
   * Axis C++ defined type for xml basic type double
   */
  typedef double xsd__double;
  /**
   * @typedef xsd__boolean
   * Axis C++ defined type for xml basic type boolean
   */
  typedef enum { false_=0, true_ } xsd__boolean;
  /**
   * @typedef xsd__byte
   * Axis C++ defined type for xml basic type byte
   */
  typedef signed char xsd__byte;
  /**
   * @typedef xsd__QName
   * Axis C++ defined type for xml basic type QName
   */
  typedef AxisChar * xsd__QName;
  /**
   * @typedef xsd__NCName
   * Axis C++ defined type for xml basic type NCName
   */
  typedef AxisChar * xsd__NCName;
  /**
   * @typedef xsd__dateTime
   * Axis C++ defined type for xml basic type dateTime
   */
  typedef struct tm xsd__dateTime;
  /**
   * @typedef xsd__date
   * Axis C++ defined type for xml basic type date
   */
  typedef struct tm xsd__date;
  /**
   * @typedef xsd__time
   * Axis C++ defined type for xml basic type time
   */
  typedef struct tm xsd__time;
  /**
   * @typedef xsd__unsignedByte
   * Axis C++ defined type for xml basic type unsignedByte
   */
  typedef unsigned char xsd__unsignedByte;
  /**
   * @typedef xsd__unsignedInt
   * Axis C++ defined type for xml basic type unsignedInt
   */
  typedef unsigned int xsd__unsignedInt;
  /**
   * @typedef xsd__unsignedLong
   * Axis C++ defined type for xml basic type unsignedLong
   */
  typedef unsigned long xsd__unsignedLong;
  /**
   * @typedef xsd__unsignedShort
   * Axis C++ defined type for xml basic type unsignedShort
   */
  typedef unsigned short xsd__unsignedShort;
  
  /**
   * @class xsd__base64Binary
   * Axis C++ defined type for xml basic type base64Binary
   */
  class STORAGE_CLASS_INFO xsd__base64Binary {
  public:
      xsd__base64Binary();
      ~xsd__base64Binary();
      xsd__unsignedByte * __ptr;
      xsd__int __size;
  };
  
  /**
   * @class xsd__hexBinary
   * Axis C++ defined type for xml basic type hexBinary
   */
  class STORAGE_CLASS_INFO xsd__hexBinary {
  public:
      xsd__hexBinary();
      ~xsd__hexBinary();
      xsd__unsignedByte * __ptr;
      xsd__int __size;
  };
  
  /**
   * @typedef xsd__anyURI
   * Axis C++ defined type for xml basic type anyURI
   */
  typedef AxisChar * xsd__anyURI;
  /**
   * @typedef xsd__NMTOKEN
   * Axis C++ defined type for xml basic type anyURI
   */
  typedef AxisChar * xsd__NMTOKEN;
  /**
   * @enum AXIS_BINDING_STYLE
   * Enumeration for the different wsdl styles. This is used by the Axis
   * engine to identify the web service or client style.
   */
  typedef enum {
      RPC_ENCODED, /*default*/
      DOC_LITERAL,
      RPC_LITERAL
  } AXIS_BINDING_STYLE;
  
  #define AXIS_DEFINED_ARRAY(type) \
      class type##_Array {\
        public:\
          type * m_Array;\
          int m_Size;\
      };
  
  class Axis_Array {
    public:
      void* m_Array;
      int m_Size;
  };
  
  AXIS_DEFINED_ARRAY(xsd__string)
  AXIS_DEFINED_ARRAY(xsd__integer)
  AXIS_DEFINED_ARRAY(xsd__int)
  AXIS_DEFINED_ARRAY(xsd__long)
  AXIS_DEFINED_ARRAY(xsd__short)
  AXIS_DEFINED_ARRAY(xsd__decimal)
  AXIS_DEFINED_ARRAY(xsd__float)
  AXIS_DEFINED_ARRAY(xsd__double)
  AXIS_DEFINED_ARRAY(xsd__boolean)
  AXIS_DEFINED_ARRAY(xsd__QName)
  AXIS_DEFINED_ARRAY(xsd__NCName)
  AXIS_DEFINED_ARRAY(xsd__dateTime)
  AXIS_DEFINED_ARRAY(xsd__unsignedByte)
  AXIS_DEFINED_ARRAY(xsd__unsignedInt)
  AXIS_DEFINED_ARRAY(xsd__unsignedLong)
  AXIS_DEFINED_ARRAY(xsd__unsignedShort)
  AXIS_DEFINED_ARRAY(xsd__base64Binary)
  AXIS_DEFINED_ARRAY(xsd__hexBinary)
  AXIS_DEFINED_ARRAY(xsd__anyURI)
  AXIS_DEFINED_ARRAY(xsd__NMTOKEN)
   
  #define AXIS_OUT_PARAM 
  
  static const int xsd_boolean_true = 1;
  static const int xsd_boolean_false = 0;
  
  typedef enum {
      NORMAL_CHANNEL=0,
      SSL_CHANNEL
  } AXIS_CHANNEL_TYPE;
  
  /**
   * @typedef XML_String
   * Axis C++ defined type for xml encoded string. This is used only in AnyType.
   */
  typedef char* XML_String;
  
  /**
   * @class AnyType
   * Axis C++ defined type for handling xsd:any.
   */
  class STORAGE_CLASS_INFO AnyType
  {
  public:
      AnyType();
      ~AnyType();
  
      /**
       * @var _array Contains an array of xml encoded strings.
       */
      XML_String* _array;
  
      /**
       * @var _size Contains how many xml strings are there in _array
       */
      int _size;
  };
  
  AXIS_CPP_NAMESPACE_END
  #endif
  
  
  
  1.1                  ws-axis/c/include/axis/AxisWrapperAPI.hpp
  
  Index: AxisWrapperAPI.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   *
   *
   */
  
  #if !defined(_AXISWRAPPERAPI_H____OF_AXIS_INCLUDED_)
  #define _AXISWRAPPERAPI_H____OF_AXIS_INCLUDED_
  
  #include "IWrapperSoapDeSerializer.hpp"
  #include "IWrapperSoapSerializer.hpp"
  #include "BasicHandler.hpp"
  
  AXIS_CPP_NAMESPACE_START
  
  /**
   * @file AxisWrapperAPI.hpp
   * This file contains the API functions that are implemented by the WSDL2Ws
   * tool generated code to manipulate C/C++ type for each complex type in a xml
   * schema.
   * @author Susantha Kumara (susantha@opensource.lk, skumara@virtusa.com)
   */
   
  /**
   * @fn AXIS_DESERIALIZE_FUNCT
   * Function that deserializes a custom type 
   */
  typedef int (* AXIS_DESERIALIZE_FUNCT)(void*, void*);
  
  /**
   * @fn AXIS_OBJECT_CREATE_FUNCT
   * Function used to create a custom type. bArray is true if array of 
   * objects to be created. Then nSize is the size of that array.
   */
  typedef void* (* AXIS_OBJECT_CREATE_FUNCT)(void*, bool bArray, int nSize);
  
  /**
   * @fn AXIS_OBJECT_DELETE_FUNCT
   * Function used to delete a custom type. bArray is true if void* is a 
   * pointer to an array. Then nSize is the size of that array.
   */
  typedef void (* AXIS_OBJECT_DELETE_FUNCT)(void*, bool bArray, int nSize);
  
  /**
   * @fn AXIS_SERIALIZE_FUNCT
   * Function that serializes a custom type. bArray indicates that the object 
   * in void is an element of an array (note that void* is not itself an array).
   */
  typedef int (* AXIS_SERIALIZE_FUNCT)(void*, void*, bool bArray);
  
  /**
   * @fn AXIS_OBJECT_SIZE_FUNCT
   * Function that is used to get the size of an object of a custom type.
   */
  typedef int (* AXIS_OBJECT_SIZE_FUNCT)(void);
  
  AXIS_CPP_NAMESPACE_END
  
  #endif
   
  
  
  
  1.1                  ws-axis/c/include/axis/BasicHandler.hpp
  
  Index: BasicHandler.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   *
   *
   */
  
  /**
   * @file BasicHandler.hpp
   *
   * @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_
  
  #include <axis/server/IMessageData.hpp>
  #include "GDefine.hpp"
  
  AXIS_CPP_NAMESPACE_START
  
  enum HANDLER_TYPE { NORMAL_HANDLER, WEBSERVICE_HANDLER, CHAIN_HANDLER };
  
  typedef struct 
  {
      int (AXISCALL* invoke)(void* _object, void* pMsg);
      void (AXISCALL* onFault)(void* _object, void* pMsg);
      int (AXISCALL* init)(void* _object);
      int (AXISCALL* fini)(void* _object);
      int (AXISCALL* getType)(void* _object);
      AXIS_BINDING_STYLE (AXISCALL* getBindingStyle)(void* _object);
  } BasicHandlerFunctions;
  
  typedef struct 
  {
      void* _object; 
      /* present only for interfaces passed from C to C++ (eg:BasicHandler) */
      BasicHandlerFunctions* _functions;
  } BasicHandler;
  
  /**
    * @class HandlerBase
    * @brief interface for the Handlers. This is the base class for:
    *        - 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.
    * Each of these handlers will inherit from this HandlerBase which serves as
    * the base point for all the different types of Handlers.
    *
    * @author Susantha Kumara (skumara@virtusa.com)
    * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com)
    *
    */
  
  /*
   * Revision 1.1  2004/06/14 roshan
   * Added doxygen comments to help autobuild API docs
   */
  
  class HandlerBase
  {
  public:
      /**
        * Constructor.
        */
      HandlerBase(){};
  
      /**
        * 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.
        */
      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.
        *
        * @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.
        */
      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.
        */
      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.
        */
      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
        */
      virtual int AXISCALL getType()=0;
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif 
  
  
  
  
  
  1.1                  ws-axis/c/include/axis/BasicNode.hpp
  
  Index: BasicNode.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   */
  
  
  /**
   * @file BasicNode.hpp
   *
   * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com)
   */
    
  #if !defined(_BASICNODE_H____OF_AXIS_INCLUDED_)
  #define _BASICNODE_H____OF_AXIS_INCLUDED_
  
  #include "GDefine.hpp"
  #include <axis/IAttribute.hpp>
  #include <list>
  
  AXIS_CPP_NAMESPACE_START
  using namespace std;
  
  class SoapSerializer;
  
  AXIS_CPP_NAMESPACE_END
  
  enum NODE_TYPE { ELEMENT_NODE=1, CHARACTER_NODE};
  
  /*
   * @class BasicNode
   * @brief interface for the BasicNode class.
   *
   * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com)
   * @author Samisa Abeysinghe (sabeysinghe@virtusa.com)
   *
   */
  
  /*
   * Revision 1.1  2004/05/25 samisa
   * Added constructors, copy constructure and pure virtual clone for copy constructing derived classes
   */
  
  /*
   * Revision 1.2  2004/06/13 roshan
   * Added doxygen comments to help autobuild API docs
   */
  
  /*
   * Revision 1.3  2004/07/28 roshan
   * Added the method getLocalName()
   */
  
  AXIS_CPP_NAMESPACE_START
  using namespace std;
  
  class BasicNode
  {
  public:
  
      /**
        * Returns the Attribute of this node, corresponding to the given 
        * prefix/localname pair or the given namespace URI/localname pair. 
        * The users could get the attributes with the 
        * following combinations of pairs.
        *  1. by prefix and localname pair (here the namespace URI(i.e pachURI
        *      has to be a empty string)) or
        *  2. by namespace URI and localname pair (here the prefix
        *      (i.e pachPrefix has to be a empty string)).
        * The operation behavior depends on the TYPE of the node.
        */
      virtual IAttribute* getAttribute(AxisChar* pachPrefix, AxisChar* pachURI, AxisChar* pachLocalname) = 0;
  
      /**
        * Returns the first Attribute of this node. The operation
        * behavior depends on the TYPE of the node.
        */
      virtual IAttribute* getFirstAttribute() = 0;
  
      /**
        * Returns the last Attribute of this node. The operation
        * behavior depends on the TYPE of the node.
        */
      virtual IAttribute* getLastAttribute() = 0;
  
      /**
        * Returns the next Attribute of this node. The operation
        * behavior depends on the TYPE of the node.
        */
      virtual IAttribute* getNextAttribute() = 0;
  
      /**
        * Returns the current Attribute of this node. The operation
        * behavior depends on the TYPE of the node.
        */
      virtual IAttribute* getCurrentAttribute() = 0;
  
  
      /** 
        * Creates an Attribute and adds it to this Basic Node. 
        * 
        * @param localname The local name of the attribute. 
        * @param prefix The prefix of the attribute. 
        * @param uri The namespace uri of the attribute. 
        * @param value The value of the attribute. 
        * 
        * @return A pointer to the created Attribute will be returned. 
        */
      virtual IAttribute* createAttribute(const AxisChar* localname, 
              const AxisChar* prefix, const AxisChar* uri, 
              const AxisChar* value) =0;
  
      /** 
        * Creates an Attribute and adds it to this Basic Node. 
        * 
        * @param localname The local name of the attribute. 
        * @param prefix The prefix of the attribute. 
        * @param value The value of the attribute. 
        * 
        * @return A pointer to the created Attribute will be returned. 
        */
      virtual IAttribute* createAttribute(const AxisChar* localname,
          const AxisChar* prefix, const AxisChar* value)=0 ;
  
      /**
        * Creates an Attribute and adds it to this Basic Node.
        *
        * @param localname The local name of the attribute.
        * @param value The value of the attribute.
        *
        * @return A pointer to the created Attribute will be returned.
        */
      virtual IAttribute* createAttribute(const AxisChar* localname,
          const AxisChar* value)=0 ;
  
      /**
        * Returns the local name of this node. The operation
        * behavior depends on the TYPE of the node.
        * 
        * @return The localname of this element.
        */
      virtual const AxisChar* getLocalName() = 0; 
  
      /**
        * Returns the number of child elements of this element. The operation
        * behavior depends on the TYPE of the node.
        *
        * @return The number of child elements of this element. The return value
        * behavior depends on the TYPE of the node.
        */
      virtual int getNoOfChildren() = 0;
  
      /**
        * Gets the first Child Node of this Complex Element. The operation
        * behavior depends on the TYPE of the node.
        *
        * @return The first Child Node of this Element.
        */
      virtual const BasicNode* getFirstChild() const = 0;
  
      /**
        * Gets the last Child Node of this Complex Element. The operation
        * behavior depends on the TYPE of the node.
        *
        * @return The last Child Node of this Element.
        */
      virtual const BasicNode* getLastChild() const = 0;
  
      /**
        * Get the Child Node of the given position. The operation behavior
        * depends on the TYPE of the node.
        *
        * @param iChildPosition The child position.
        * @return The Child Node of the given position.
        */
      virtual const BasicNode* getChild(int iChildPosition) const = 0;
  
      /**
        * Adds the given child node to this Element. The operation behavior
        * depends on the TYPE of the node.
        *
        * @param pBasicNode the child node to be added to this Element.
        * @return AXIS_SUCCESS to indicate successfull operation.
        */
      virtual int addChild(BasicNode* pBasicNode) =0;
  
      /**
        * Gets the Node Type of the Element.
        *
        * @return The Node Type of the Element.
        */
      virtual NODE_TYPE getNodeType() const =0;
  
      /**
        * Gets and return the value of this Element. The operation behavior
        * depends on the TYPE of the node.
        *
        * @return The value of this Element.
        */    
      virtual const AxisChar* getValue() const =0;
  
      /**
        * Sets the value of this Element. The operation behavior
        * depends on the TYPE of the node.
        *
        * @param pachValue The value to be set
        * @return AXIS_SUCCESS to indicate success.
        */   
      virtual int setValue(const AxisChar* pachValue)=0;
      
      /**
        * Sets the namespace URI of this Element. The operation behavior
        * depends on the TYPE of the node.
        *
        * @param pachURI the namespace URI of this Element.
        * @return AXIS_SUCCESS to indicate successfull operation.
        */
      virtual int setURI(const AxisChar* sURI) =0;
  
      /**
        * Sets the local name of this Element. The operation behavior
        * depends on the TYPE of the node.
        *
        * @param pachLocalName the local name of this Element.
        * @return AXIS_SUCCESS to indicate successfull operation.
        */
      virtual int setLocalName(const AxisChar* sLocalName) =0;
  
      /**
        * Sets the prefix of this Element. The operation behavior
        * depends on the TYPE of the node.
        *
        * @param pachPrefix the prefix of this Element.
        * @return AXIS_SUCCESS to indicate successfull operation.
        */
      virtual int setPrefix(const AxisChar* sPrefix) =0;
  
      /**
        * Returns the namespace URI of this node.  The operation behavior
        * depends on the TYPE of the node.
        */
      virtual const AxisChar* getURI() = 0;
  
      /**
        * Returns the prefix  of this node.  The operation behavior
        * depends on the TYPE of the node.
        */
      virtual const AxisChar* getPrefix() = 0;
  
      virtual int serialize(SoapSerializer& pSZ) =0;
      virtual int serialize(SoapSerializer& pSZ, 
      std::list<AxisChar*>& lstTmpNameSpaceStack) =0;
      BasicNode();
      BasicNode(const AxisChar* pachValue, NODE_TYPE eNodeType = ELEMENT_NODE);
      BasicNode(const BasicNode& rCopy);
      virtual BasicNode* clone() = 0;
      virtual ~BasicNode();
  
  protected:
      /**
        * Used to store the Node Type, which is either ELEMENT_NODE or 
        * CHARACTER_NODE.
        */
      NODE_TYPE m_iNodeType;
  
      /**
        * Used to store the value. The usage of this variable depends on the TYPE
        * of the node.
        */
      AxisChar* m_pachValue;
  
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif 
  
  
  
  
  1.1                  ws-axis/c/include/axis/GDefine.hpp
  
  Index: GDefine.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   *
   *
   * @author Susantha Kumara (skumara@virtusa.com)
   *
   */
  #ifdef WIN32
  #pragma warning (disable : 4786)
  #pragma warning (disable : 4530)
  #endif
  
  #if !defined(__GDEFINE_OF_AXIS_INCLUDED__)
  #define __GDEFINE_OF_AXIS_INCLUDED__
  
  /* This file contains all global definitions that are valid across whole
   * Axis C++ project.
   */
  
  typedef enum {SECURE, UNSECURE} AXIS_SECURE_PROTOCOL;
  
  typedef enum 
  { 
      AXIS_SUCCESS=0, 
      AXIS_FAIL = -1, 
      AXIS_OBJECT_ALREADY_EXISTS=1,
      AXIS_NO_SUCH_HANDLER,
      AXIS_NO_SUCH_SERVICE
  } AXIS_GLOBAL_ERROR;
  typedef enum 
  { 
      APT_UNKNOWN = -1, APTHTTP1_0=0, APTHTTP1_1, APTFTP, APTSMTP, APTHTTPS, APTOTHER
  } AXIS_PROTOCOL_TYPE;
  
  typedef enum 
  {
      SOAPACTION_HEADER,
      SERVICE_URI,
      OPERATION_NAME,
      SOAP_MESSAGE_LENGTH,
  	SECURE_PROPERTIES
  } AXIS_TRANSPORT_INFORMATION_TYPE;
  
  #define SOAPACTIONHEADER "SOAPAction"
  
  #define AxisChar char
  #define AxisXMLCh char
  #define XML_Ch AxisChar
  
  #define AXIS_CPP_NAMESPACE_START namespace axiscpp {
  #define AXIS_CPP_NAMESPACE_END }
  /*
  The following is necessary for the skeletons and stubs to be built
  */
  namespace axiscpp {}
  
  #define AXIS_CPP_NAMESPACE_USE using namespace axiscpp;
  #define AXIS_CPP_NAMESPACE_PREFIX axiscpp::
  
  #define AxisString basic_string<char>
  #define AxisXMLString basic_string<AxisXMLCh>
  
  #ifdef WIN32
      #define AxisSprintf(X, Y, Z, W) sprintf(X, Z, W)
  #else /* linux */
      #define AxisSprintf(X, Y, Z, W) sprintf(X, Z, W)
  #endif
  
  extern void Ax_Sleep(int);
  extern void ModuleInitialize();
  extern void ModuleUnInitialize();
  
  #if defined(WIN32) 
  #define STORAGE_CLASS_INFO __declspec(dllexport)
  #else
  #define STORAGE_CLASS_INFO 
  #endif
  
  #if defined(__GNUC__)
  /*replaced stdcall with cdecl to make it work on some platforms with older libraries - Samisa*/
  /*#define AXISCALL __attribute__((stdcall))*/
  #define AXISCALL __attribute__((cdecl))
  #else /* unix or win32 */
  #if defined(__unix)
  #define AXISCALL
  #else
  #define AXISCALL __stdcall
  #endif
  #endif
  
  
  /*
   * Following macro define an API function of Axis C++
   * Format of the AXISAPI macro is as follows
   * AXISAPI(<METHOD NAME>, <PARAMETER LIST>)
   */
  
  #define AXISAPI(M, P) AXISCALL M P = 0;
  #define APIHASPARAMS
  #define APINOPARAMS 
  
  #endif 
  
  
  
  
  
  1.1                  ws-axis/c/include/axis/Handler.hpp
  
  Index: Handler.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   */
   
  #ifdef WIN32
  #pragma warning (disable : 4786)
  #endif
  
  #if !defined(__HANDLER_OF_AXIS_INCLUDED__)
  #define __HANDLER_OF_AXIS_INCLUDED__
  
  #include "BasicHandler.hpp"
  
  /**
   * @class Handler
   * @brief interface for handlers.
   *
   * @author Damitha Kumarage (damitha@opensource.lk, damitha@jkcsworld.com)
   * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com)
   */
  
  /*
   * Revision 1.1  2004/06/14 roshan
   * Added doxygen comments to help autobuild API docs
   * Added the implementations of getOption(const string& sArg) and 
   *  setOptionList(const map<string, string>* OptionList), because these methods
   *  are not needed to be implemented by the users. These are generic methods.
   */
  
  AXIS_CPP_NAMESPACE_START
  
  class Handler : public HandlerBase
  {
  public:
  	/**
  	  * Constructor.
  	  */
      Handler(){};
  
  	/**
  	  * Destructor.
  	  */
      virtual ~Handler(){};
  
  	/**
  	  * Returns the value of the given option.
  	  *
  	  * @param sArg The option name, i.e key
  	  * @return The option value.
  	  */
      const string& getOption(const string& sArg)
  	{
  		m_sEmpty = "";
  
  		map<string, string>::const_iterator it = m_pOption->find(sArg);
  		if (it != m_pOption->end())
  		{
  			return (*it).second;
  		}
  		return m_sEmpty;	
  	}
  
  	/**
  	  * This method is automatically called by the Axis Engine when it loads a
  	  * Handler. The purpose of this method is described below:
  	  * For each Handler we could configure various parameters/options in the
  	  * Server.wsdd or Client.wsdd. If the engine finds any such options then
  	  * the engine will automaticaly call this method of each handler and will
  	  * set those options to each Handler by calling this method of each 
  	  * Handler which those configuration options belong to. Normaly a Handler
  	  * writer doesn't need to interact/deal with this method.
  	  *
  	  * @param OptionList The map which contains the options to be set.
  	  */
      void setOptionList(const map<string, string>* OptionList) {m_pOption = OptionList;};
  
  	/**
  	  * Gets and returns the type of the handler. The return value here is
  	  * always NORMAL_HANDLER.
  	  *
  	  *	@return returns the type of the handler. The return value here is
  	  * always NORMAL_HANDLER.
  	  */
      int AXISCALL getType(){return NORMAL_HANDLER;};
  
  protected:
  	/**
  	  * Used to store the options which are configured in the WSDD.
  	  */
  	const map<string, string>* m_pOption;
  
  	/**
  	  * Represents an empty string.
  	  */
  	string m_sEmpty;
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif 
  
  
  
  
  1.1                  ws-axis/c/include/axis/IHandlerSoapDeSerializer.hpp
  
  Index: IHandlerSoapDeSerializer.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   */
  
  
  #if !defined(_IHANDLERSOAPDESERIALIZER_H____OF_AXIS_INCLUDED_)
  #define _IHANDLERSOAPDESERIALIZER_H____OF_AXIS_INCLUDED_
  
  #include "IWrapperSoapDeSerializer.hpp"
  #include "IHeaderBlock.hpp"
  #include "AxisUserAPI.hpp"
  /*
   *  @class IHandlerSoapDeSerializer
   *  @brief interface for the IHandlerSoapDeSerializer class.
   *
   *
   *  @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com)
   */
  
  /*
   * Revision 1.1  2004/06/14 roshan
   * Removed virtual int AXISCALL addHeaderBlock(IHeaderBlock* pBlk)=0; method
   * from this interface, because a user should not be able to add any thing
   * to the DeSerialzer.
   */
  
  AXIS_CPP_NAMESPACE_START
  
  class IHandlerSoapDeSerializer : public IWrapperSoapDeSerializer
  {
  public:
      virtual ~IHandlerSoapDeSerializer() {};
      
      /*
       * The soap body may be encrypted/compressed and a 
       * handler in the request message 
       * path may decode and then decrypt and/or decompress 
       * whole soap body and set the
       * XML to the Deserializer. In such a case a handler 
       * will use following functions 
       * to get soap body and set back the XML. 
       * If this process goes throgh several
       * handlers the intermediate binary data 
       * (unencrypted/uncompressed body) may be kept 
       * in the IMessageData until it is converted to XML. 
       * A handler usually converts it 
       * to XML and use SetNewSoapBody(..) function to set 
       * the new SoapBody back to the 
       * Deserializer.
       */
      virtual xsd__hexBinary AXISCALL getBodyAsHexBinary()=0;
      virtual xsd__base64Binary AXISCALL getBodyAsBase64Binary()=0;
      virtual int AXISCALL setNewSoapBody(AxisChar* pNewSoapBody)=0;
  
  	/**
  	  * Gets and returns the Header Block of the given local name and 
  	  * namespace uri. After returning the Header Block pointer, it will be
  	  * removed from the available Header Block list of the DeSerializer.
  	  * It is the responsibilty of the caller of this method to delete the
  	  * returned pointer object, to avoid memory leaks.
  	  */
      virtual IHeaderBlock* getHeaderBlock(const AxisChar* pName, 
          const AxisChar* pNamespace) = 0;
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif 
  
  
  
  
  
  1.1                  ws-axis/c/include/axis/IHandlerSoapSerializer.hpp
  
  Index: IHandlerSoapSerializer.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   */
  
  #if !defined(_IHANDLERSOAPSERIALIZER_H____OF_AXIS_INCLUDED_)
  #define _IHANDLERSOAPSERIALIZER_H____OF_AXIS_INCLUDED_
  
  #include "IWrapperSoapSerializer.hpp"
  #include "SoapEnvVersions.hpp"
  
  AXIS_CPP_NAMESPACE_START
  
  class IHeaderBlock;
  /**
    * @class IHandlerSoapSerializer
    * @brief interface for the IHandlerSoapSerializer class. This interface is
    *	exposed to a Handler Writer, to let him manipulate on the Serialzer object.
    * Example usage is given below.
    * <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");
    * </PRE>
    * 
    * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com)
    */
  class IHandlerSoapSerializer : public IWrapperSoapSerializer
  
  {
  public:        
      virtual ~IHandlerSoapSerializer() {};
  
  	/**
  	  * Will create a Header Block and adds it to the Serializer.
  	  *
  	  * @return The created Header Block pointer will be returned, which the
  	  * user can manipulate on it.
  	  */
      virtual IHeaderBlock* createHeaderBlock()=0;
  
  	/**
  	  * Will create a Header Block using the given local name and the namespace
  	  * uri, and adds it to the Serializer.
  	  *
  	  * @param pachLocalName The local name of the Header Block
  	  * @param pachUri The namespace uri of the Header Block.
  	  * @return The created Header Block pointer will be returned, which the
  	  * user can manipulate on it.
  	  */
      virtual IHeaderBlock*  createHeaderBlock(AxisChar *pachLocalName, 
  		AxisChar *pachUri)=0;    
  
  	/**
  	  * Adds the given Header Block to the Serialzer.
  	  *
  	  * @param pBlk The Header Block to be added.
  	  * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
  	  */
      virtual int AXISCALL addHeaderBlock(IHeaderBlock* pBlk)=0;
  
  	/**
  	  * Sets the SOAP Version.
  	  * @param eSOAP_VERSION The SOAP version to set.
  	  * @return AXIS_SUCCESS to indicate success.
  	  */
      virtual int setSoapVersion(SOAP_VERSION eSOAP_VERSION)=0;
  
  	/**
  	  * Gets the Header Block. After returning the Header Block pointer, it 
  	  * will not be removed from the available Header Block list of the 
  	  * Serializer.The caller of this method should not delete the returned 
  	  * pointer object.
  	  */
  	virtual IHeaderBlock* getHeaderBlock() = 0;
  
  	/**
  	  * Gets and returns the Header Block of the given local name and 
  	  * namespace uri.After returning the Header Block pointer, it will not be
  	  * removed from the available Header Block list of the Serializer.
  	  * The caller of this method should not delete the returned pointer 
  	  * object.
  	  */
  	virtual IHeaderBlock* getHeaderBlock(const AxisChar *pcName, 
  											 const AxisChar *pcNamespace) = 0;
       /**
        * Used with getNextHeaderBlock, it returns the first header block,
        * or NULL if there are no headers.
        */
       virtual IHeaderBlock* getFirstHeaderBlock()=0;
   
       /**
        * Used with getFirstHeaderBlock, it returns the next header block,
        * or NULL if there are no headers.
        */
       virtual IHeaderBlock* getNextHeaderBlock()=0;
  
      /*
       * A handler may get the entire soap body and encrypt/compress 
       * it and encode to either base64Binary or hexBinary before 
       * sending to the trasport. So any handler in the response message 
       * path may use following functions to get the entire soap 
       * body / set encrypted and/or compressed and then encoded soap body
       * back to the Serializer
       */
  
      virtual int AXISCALL setBodyAsHexBinary(xsd__hexBinary body)=0;
      virtual int AXISCALL setBodyAsBase64Binary(xsd__base64Binary body)=0;
      virtual const AxisChar* AXISCALL getBodyAsString()=0;
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif 
  
  
  
  
  1.1                  ws-axis/c/include/axis/IHeaderBlock.hpp
  
  Index: IHeaderBlock.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   */
  
  #if !defined(_IHEADERBLOCK_H____OF_AXIS_INCLUDED_)
  #define _IHEADERBLOCK_H____OF_AXIS_INCLUDED_
  
  #include "BasicNode.hpp"
  #include "SoapEnvVersions.hpp"
  #include <axis/IAttribute.hpp>
  
  enum HEADER_BLOCK_STD_ATTR_TYPE 
  {   ROLE_NEXT=1, ROLE_NONE=2, 
      ROLE_ULTIMATE_RECEIVER=3, 
      ACTOR=4, MUST_UNDERSTAND_TRUE= 5, 
      MUST_UNDERSTAND_FALSE=6
  };
  
  
  /**
   *  @class IHeaderBlock
   *  @brief interface for the IHeaderBlock class.
   *
   *
   *  @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com)
   *  @author Samisa Abeysinghe (sabeysinghe@virtusa.com)
   *  @author Susantha Kumara (susantha@opensource.lk, skumara@virtusa.com)
   *
   */
  
  /*
   * Revision 1.1  2004/05/26 samisa
   * Added copy constructor and clone
   */
  
  /*
   * Revision 1.2  2004/06/13 roshan
   * Added doxygen comments to help autobuild API docs
   */
  
  /*
   * Revision 1.12  2004/06/13 susantha
   * Added support for writing C web services and handlers
   */
  AXIS_CPP_NAMESPACE_START
  
  class IHeaderBlock
  {
  public:
      /** 
        * Sets the namespace declaration of the Header Block. 
        * 
        * @param pAttribute The Attribute pointer which points to a valid 
        * namespace declartion Attribute. 
        * @return AXIS_SUCCESS to indicate successfull operation. 
        */ 
      virtual int addNamespaceDecl(IAttribute *pAttribute)=0;
  
      /** 
        * Creates a Attribute and adds it to this Header Block as a namespace. 
        * 
        * @param prefix The prefix of the attribute. 
        * @param uri The namespace uri of the attribute. 
        * 
        * @return A pointer to the created Attribute will be returned. 
        */ 
      virtual IAttribute* createNamespaceDecl(const AxisChar *prefix, 
              const AxisChar *uri)=0; 
  
      virtual const BasicNode* getFirstChild() =0;
      /**
       * Returns the number of child elements of this HeaderBlock.
       *
       * @return The number of child elements of this HeaderBlock.
       */
      virtual int getNoOfChildren() =0;
  
      /**
        * Creates a child node depending on the given node type. i.e:
        * if node type == CHARACTER_NODE then it creates a Character Element.
        * if node type == ELEMENT_NODE then it creates a Complex Element.
        * This method doesn't add the created child to this Header Block. If the
        * user needs to add this created child then he has to use the
        * addChild(BasicNode *pBasicNode) method after creating the child.
        * If the node to be created is a CHARACTER_NODE then only the parameter
        * pachValue will be usefull and for others you can provide NULL.
        * If the node to be created is a ELEMENT_NODE then the parameters 
        * pachLocalName, pachPrefix, pachUri will be needed to provide and you
        * can provide NULL for the pachValue.
        *
        * @param eNODE_TYPE The node type to be created, i.e CHARACTER_NODE or
        * ELEMENT_NODE.
        * @param pachLocalName The local name of the child node. A CHARACTER_NODE
        * will ignore this.
        * @param pachPrefix The prefix of the child node. A CHARACTER_NODE
        * will ignore this.
        * @param pachUri The namespace uri of the child node. A CHARACTER_NODE
        * will ignore this.
        * @param pachValue The value of the child node. A ELEMENT_NODE
        * will ignore this.
        * 
        * @return The child node created will be returned if the creation is
        * successfull. If the creation is unsccessfull it will return NULL.
        */
      virtual BasicNode* createChild(NODE_TYPE eNODE_TYPE,  
          AxisChar *pachLocalName, AxisChar *pachPrefix, AxisChar *pachUri, 
          AxisChar* pachValue) = 0;
  
    /**
     * Creates a child node depending on the given type. If the type is 
     *  CHARACTER_NODE a CharacterElement is created. If the type is 
     *  ELEMENT_NODE a ComplexElement is created. After creating the child it
     *  will be added as a immediate child to the header block.
     *  It is important to note that if the type is CHARACTER_NODE only the
     *  NODE_TYPE and value (pachValue) parameters will be usefull.If the type
     *  is ELEMENT_NODE the parameters NODE_TYPE, pachLocalName, pachPrefix, 
     *  pachUri will be usefull.
     *
     * @param eNODE_TYPE The type of the child to be created, it should be either 
     *  CHARACTER_NODE for CharacterElements or ELEMENT_NODE for 
     *  ComplexElements.
     * @param pachLocalName The local name of the complex element to be created.
     * @param pachPrefix The prefix of the complex element to be created.
     * @param pachUri The namespace uri of the complex element to be created.
     * @param pachValue The value of the character element to be created.
     *
     * @return The child node created will be returned if the creation is
     *  successfull. If the creation is unsccessfull it will return NULL.
     */    
      virtual BasicNode* createImmediateChild(NODE_TYPE eNODE_TYPE, 
          AxisChar *pachLocalName, AxisChar *pachPrefix, AxisChar *pachUri, 
          AxisChar* pachValue) = 0;
  
      /**
       * A user can use this method to create a standard HeaderBlock attribute. 
       * The types of HEADER_BLOCK_STD_ATTR_TYPE are:
       * ROLE_NEXT : To create the role attribute to point to next.
       * ROLE_NONE : To create the role attribute to point to none.
       * ROLE_ULTIMATE_RECEIVER : To create the role attribute to point to 
       * ultimate receiver.
       * ACTOR : To create the actor attribute to point to next.
       * MUST_UNDERSTAND_TRUE : To create the mustUnderstand attribute to 
       * point to true.
       * MUST_UNDERSTAND_FALSE : To create the mustUnderstand attribute to 
       * point to false.
       * To use ROLE_NEXT, 
       * ROLE_NONE, ROLE_ULTIMATE_RECEIVER, MUST_UNDERSTAND_TRUE,
       * MUST_UNDERSTAND_FALSE the user has to pass SOAP_VER_1_2 as the 
       * SOAP_VERSION.
       * To use ACTOR, MUST_UNDERSTAND_TRUE, MUST_UNDERSTAND_FALSE the user has 
       * to pass SOAP_VER_1_1 as the SOAP_VERSION.
       *
       * @param eStdAttrType The standard attribute to be created.
       * The current values that can be passes are: ROLE_NEXT, ROLE_NONE, 
       * ROLE_ULTIMATE_RECEIVER, ACTOR, MUST_UNDERSTAND_TRUE,
       * MUST_UNDERSTAND_FALSE.
       * @param eSOAP_VERSION The related soap version. 
       * The vallues which could be
       * passes are SOAP_VER_1_1 and SOAP_VER_1_2.
       *
       * @return A pointer to the created standard Attribute will be returned.
       */
      virtual IAttribute* createStdAttribute(HEADER_BLOCK_STD_ATTR_TYPE 
          eStdAttrType, SOAP_VERSION eSOAP_VERSION) =0;
  
      /**
        * Creates a Attribute and adds it to this Header Block.
        *
        * @param localname The local name of the attribute.
        * @param prefix The prefix of the attribute.
        * @param uri The namespace uri of the attribute.
        * @param value The value of the attribute.
        *
        * @return A pointer to the created Attribute will be returned.
        */
      virtual IAttribute* createAttribute(const AxisChar* localname, 
          const AxisChar* prefix, 
          const AxisChar* uri, const AxisChar* value) = 0;
  
      /**
        * Creates a Attribute and adds it to this Header Block.
        *
        * @param localname The local name of the attribute.
        * @param prefix The prefix of the attribute.
        * @param value The value of the attribute.
        *
        * @return A pointer to the created Attribute will be returned.
        */
      virtual IAttribute* createAttribute(const AxisChar *localname, 
          const AxisChar *prefix, const AxisChar *value) = 0;
       /**
        * Gets an Attribute from the HeaderBlock.
        *
        * @param localname The local name of the attribute.
        * @param prefix The prefix of the attribute.
        *
        * @return the value of the attribute is returned.
        */
       virtual const AxisChar* getAttributeValue(const AxisChar* localname,
           const AxisChar* prefix) = 0;
   
  
      /**
       * Creates a child node depending on the given type. If the type is 
       * CHARACTER_NODE a CharacterElement is created. If the type is 
       * ELEMENT_NODE a ComplexElement is created. After creating the child it
       * will be added as a immediate child to the header block.
       *
       * @param The type of the child to be created, it should be either 
       * CHARACTER_NODE for CharacterElements or ELEMENT_NODE for 
       * ComplexElements.
       * @return The child node created will be returned if the creation is
       * successfull. If the creation is unsccessfull it will return NULL.
       */
      virtual BasicNode* createImmediateChild(NODE_TYPE eNODE_TYPE) = 0;
  
      /**
       * Creates a child node depending on the given type. If the type is 
       * CHARACTER_NODE a CharacterElement is created. If the type is 
       * ELEMENT_NODE a ComplexElement is created. After creating the child it
       * will not be added as a child to the header block. The user has to add
       * the created child to the appropriate locaion as his wish.
       *
       * @param eNODE_TYPE The type of the child to be created, 
       * it should be either 
       * CHARACTER_NODE for CharacterElements or ELEMENT_NODE for 
       * ComplexElements.
       * @return The child node created will be returned if the creation is
       * successfull. If the creation is unsccessfull it will return NULL.
       */
      virtual BasicNode* createChild(NODE_TYPE eNODE_TYPE)=0;
  
      /**
       * Returns the last child element. The user has to check whether the
       * method return NULL before proceding.
       *
       * @return The last child element is returned if it exists. 
       * If the child element doesn't exsist this method returns NULL.
       */
      virtual const BasicNode* getLastChild() = 0;
  
      /**
       * Returns the child element at the given postion. 
       * The user has to check whether the method return NULL before proceding.
       *
       * @param iChildPosition The positon of the required child element.
       * @return The required child element is returned if it exists. 
       * If the child element doesn't exsist this method returns NULL.
       */
      virtual const BasicNode* getChild(int iChildPosition) = 0;
  
      /**
        * Adds a child node to the Header Block.
        *
        * @param pBasicNode The child node pointer which is to be added.
        * @return AXIS_SUCCESS to indicate successfull operation.
        */
      virtual int addChild(BasicNode* pBasicNode)=0;
  
      /**
        * Sets the local name of this Header Block.
        *
        * @param localname The localname to set in.
        */
      virtual void setLocalName(const AxisChar* localname)=0;
  
      /**
        * Sets the namespace uri of this Header Block.
        *
        * @param uri The namespace uri to set in.
        */
      virtual void setUri(const AxisChar* uri)=0;
  
  	/* 
  	 * Commented by Susantha - 21/06/2004
  	 * The prefix should be decided by the Serializer at runtime
  	 * 
  	 * Uncommented by Mark Whitlock - 24/8/04 after discussion 
  	 * on the mailing list agreed to add back in this method.
  	 * Jira issue AXISCPP-135
  	 */
      /**
        * Sets the prefix of this Header Block.
        *
        * @param prefix The prefix to set in.
        */
      virtual void setPrefix(const AxisChar* prefix)=0;
  
  #ifdef UNIT_TESTING_ON
      /**
        * Initialized the Header Block for testing.
        */
      virtual int initializeForTesting() = 0;
  #endif
      
      IHeaderBlock(){/*empty body as there are no member variable*/};
  
      IHeaderBlock(const IHeaderBlock& rCopy){/*empty body as there are no member variable*/};
  
      /**
        * Creates and returns a clone of this Header Block.
        *
        * @return A clone of this Header Block.
        */
      virtual IHeaderBlock* clone() = 0;
  
      /**
        * The Destructor.
        */
      virtual ~IHeaderBlock() {};
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif 
  
  
  
  
  1.1                  ws-axis/c/include/axis/IMessageData.hpp
  
  Index: IMessageData.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   */
  
  #if !defined(_IMESSAGEDATA_H___OF_AXIS_INCLUDED_)
  #define _IMESSAGEDATA_H___OF_AXIS_INCLUDED_
  
  #include "GDefine.hpp"
  #include "IHandlerSoapDeSerializer.hpp"
  #include "IHandlerSoapSerializer.hpp"
  #include "IWrapperSoapDeSerializer.hpp"
  #include "IWrapperSoapSerializer.hpp"
  
  AXIS_CPP_NAMESPACE_START
  
  class WSDDService;
  class IAdminUtils;
  
  /*
   *   @class IMessageData
   *   @brief interface for the IMessageData class.
   *   @author Susantha Kumara (skumara@virtusa.com, susantha@opensource.lk)
   *   @author Roshan Weerasuriya (roshan@jkcs.slt.lk, roshan@opensource.lk)
   */
  class IMessageData
  {
      /* Allow AxisAdminService access to the private methods */
      friend class AxisAdminServiceWrapper; 
  public:
      virtual ~IMessageData(){};
  private:
      virtual void getAdminUtils(IAdminUtils** pIAdminUtils)=0;
  public:      
  	virtual int setProperty(AxisChar* pachName, const AxisChar* pachValue)=0;
      virtual int setProperty(AxisChar* pachName, const void* pachValue, int len)=0;
      virtual const void* getProperty(AxisChar* sName)=0;
      virtual const AxisChar* AXISCALL getOperationName()=0;
      virtual void AXISCALL getSoapSerializer(IWrapperSoapSerializer** pIWSS)=0;
      virtual void AXISCALL getSoapDeSerializer
          (IWrapperSoapDeSerializer** pIWSDS)=0;
      virtual void getSoapSerializer
          (IHandlerSoapSerializer** pIHandlerSoapSerializer)=0;
      virtual void getSoapDeSerializer
          (IHandlerSoapDeSerializer** pIHandlerSoapDeSerializer)=0;
      virtual void setUserName(string& m_sUserName)=0;
      virtual string& getUserName()=0;
      virtual void setService(const WSDDService* argService) = 0;
      virtual const WSDDService* getService() = 0; 
      virtual bool isPastPivot()=0;
      virtual int setPastPivotState(bool bState)=0;
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif
  
  
  
  
  
  
  
  
  1.1                  ws-axis/c/include/axis/IWrapperSoapDeSerializer.hpp
  
  Index: IWrapperSoapDeSerializer.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   */
  
  #if !defined(_IWRAPPERSOAPDESERIALIZER_H____OF_AXIS_INCLUDED_)
  #define _IWRAPPERSOAPDESERIALIZER_H____OF_AXIS_INCLUDED_
  
  #include "AxisUserAPI.hpp"
  #include "TypeMapping.hpp"
  #include "WSDDDefines.hpp"
  
  /**
      @class IWrapperSoapDeSerializer
      @brief interface for the IWrapperSoapDeSerializer class.
  
  
      @author Susantha Kumara (skumara@virtusa.com, susantha@opensource.lk)
      @author Roshan Weerasuriya (roshan@jkcs.slt.lk, roshan@opensource.lk)
  */
  
  AXIS_CPP_NAMESPACE_START
  
  class IWrapperSoapDeSerializer
  {
  public:
      virtual ~IWrapperSoapDeSerializer(){};
  
      virtual int AXISCALL checkMessageBody(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual void* AXISCALL checkForFault(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      /* Method used by wrappers 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 wrappers to get a deserialized Array of basic types */
      virtual Axis_Array AXISCALL getBasicArray(XSDTYPE nType, 
          const AxisChar* pName, const AxisChar* pNamespace)=0;
      /* Method used by wrappers to get a deserialized single object of 
       * complex type 
       */
      virtual void* AXISCALL getCmplxObject(void* pDZFunct, void* pCreFunct, 
          void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace)=0;
      
      /* Methods used by wrappers to get a deserialized value of basic types */
      virtual int AXISCALL getElementAsInt(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual int AXISCALL getFaultDetail(char** ppcDetail) = 0;
      virtual xsd__boolean AXISCALL getElementAsBoolean(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual unsigned int AXISCALL getElementAsUnsignedInt(const AxisChar* 
          pName, const AxisChar* pNamespace)=0;
      virtual short AXISCALL getElementAsShort(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual unsigned short AXISCALL getElementAsUnsignedShort(const AxisChar* 
          pName, const AxisChar* pNamespace)=0;
      virtual char AXISCALL getElementAsByte(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual unsigned char AXISCALL getElementAsUnsignedByte(const AxisChar* 
          pName, const AxisChar* pNamespace)=0;
  #ifdef WIN32
      virtual __int64 AXISCALL getElementAsLong(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
  #else
      virtual long long AXISCALL getElementAsLong(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
  #endif
      virtual long AXISCALL getElementAsInteger(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual unsigned long AXISCALL getElementAsUnsignedLong(const AxisChar* 
          pName, const AxisChar* pNamespace)=0;
      virtual float AXISCALL getElementAsFloat(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual double AXISCALL getElementAsDouble(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual double AXISCALL getElementAsDecimal(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual AxisChar* AXISCALL getElementAsString(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual AxisChar* AXISCALL getElementAsAnyURI(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual AxisChar* AXISCALL getElementAsQName(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual xsd__hexBinary AXISCALL getElementAsHexBinary(const AxisChar* 
          pName, const AxisChar* pNamespace)=0;
      virtual xsd__base64Binary AXISCALL getElementAsBase64Binary(const AxisChar*
          pName, const AxisChar* pNamespace)=0;
      virtual struct tm AXISCALL getElementAsDateTime(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual struct tm AXISCALL getElementAsDate(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual struct tm AXISCALL getElementAsTime(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual long AXISCALL getElementAsDuration(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
  
      virtual int AXISCALL getAttributeAsInt(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual xsd__boolean AXISCALL getAttributeAsBoolean(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual unsigned int AXISCALL getAttributeAsUnsignedInt(const AxisChar* 
          pName, const AxisChar* pNamespace)=0;
      virtual short AXISCALL getAttributeAsShort(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual unsigned short AXISCALL getAttributeAsUnsignedShort(const AxisChar*
          pName, const AxisChar* pNamespace)=0;
      virtual char AXISCALL getAttributeAsByte(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual unsigned char AXISCALL getAttributeAsUnsignedByte(const AxisChar* 
          pName, const AxisChar* pNamespace)=0;
      virtual long AXISCALL getAttributeAsLong(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual long AXISCALL getAttributeAsInteger(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual unsigned long AXISCALL getAttributeAsUnsignedLong(const AxisChar* 
          pName, const AxisChar* pNamespace)=0;
      virtual float AXISCALL getAttributeAsFloat(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual double AXISCALL getAttributeAsDouble(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual double AXISCALL getAttributeAsDecimal(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual AxisChar* AXISCALL getAttributeAsString(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual AxisChar* AXISCALL getAttributeAsAnyURI(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual AxisChar* AXISCALL getAttributeAsQName(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual xsd__hexBinary AXISCALL getAttributeAsHexBinary(const AxisChar* 
          pName, const AxisChar* pNamespace)=0;
      virtual xsd__base64Binary AXISCALL getAttributeAsBase64Binary(const 
          AxisChar* pName, const AxisChar* pNamespace)=0;
      virtual struct tm AXISCALL getAttributeAsDateTime(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual struct tm AXISCALL getAttributeAsDate(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual struct tm AXISCALL getAttributeAsTime(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual long AXISCALL getAttributeAsDuration(const AxisChar* pName, 
          const AxisChar* pNamespace)=0;
      virtual int AXISCALL getStatus()=0;
      
      /* Externalization of deserializer API */
  //    virtual int setInputStream(SOAPTransport* pInputStream)=0;
  //    virtual int init()=0;
  //    virtual PROVIDERTYPE getCurrentProviderType()=0;
  //    virtual void setCurrentProviderType(PROVIDERTYPE nType)=0;    
      virtual AXIS_BINDING_STYLE getStyle()=0;    
      virtual void setStyle(AXIS_BINDING_STYLE nStyle)=0;
      virtual int getVersion()=0;
      virtual int getHeader()=0;    
  	virtual AnyType* AXISCALL getAnyObject()=0;            
      virtual void getChardataAs(void* pValue, XSDTYPE type)=0;
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif
  
  
  
  1.1                  ws-axis/c/include/axis/IWrapperSoapSerializer.hpp
  
  Index: IWrapperSoapSerializer.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   */
  
  #if !defined(_IWRAPPERSOAPSERIALIZER_H____OF_AXIS_INCLUDED_)
  #define _IWRAPPERSOAPSERIALIZER_H____OF_AXIS_INCLUDED_
  
  #include "AxisUserAPI.hpp"
  #include "TypeMapping.hpp"
  #include "WSDDDefines.hpp"
  
  /*
   *  @class IWrapperSoapSerializer
   *  @brief interface for the IWrapperSoapSerializer class.
   *
   *
   *  @author Susantha Kumara (skumara@virtusa.com, susantha@opensource.lk)
   *  @author Roshan Weerasuriya (roshan@jkcs.slt.lk, roshan@opensource.lk)
   *
   */
  
  AXIS_CPP_NAMESPACE_START
  
  class IWrapperSoapSerializer
  {
  public:
      virtual ~IWrapperSoapSerializer(){};
  
      virtual int AXISCALL createSoapMethod(const AxisChar* sLocalName, 
          const AxisChar* sURI)=0;
  
      virtual int AXISCALL createSoapFault(const AxisChar* sLocalName, 
          const AxisChar* sURI, const AxisChar* sFaultCode,
  	const AxisChar* sFaultString)=0;
  
      virtual const AxisChar* AXISCALL getNamespacePrefix
          (const AxisChar* pNamespace)=0;
  
      virtual void AXISCALL removeNamespacePrefix(const AxisChar* pNamespace)=0;
  
      /* for basic types */
      virtual int AXISCALL addOutputParam(const AxisChar* pchName, void* pValue, 
          XSDTYPE type)=0;
  
      /* for arrays */
      virtual int AXISCALL addOutputCmplxArrayParam(const Axis_Array* pArray, 
          void* pSZFunct, void* pDelFunct, void* pSizeFunct, 
          const AxisChar* pName, const AxisChar* pNamespace)=0;
  
      virtual int AXISCALL addOutputBasicArrayParam(const Axis_Array* pArray, 
          XSDTYPE nType, const AxisChar* pName)=0;
  
      /* for complex types */
      virtual int AXISCALL addOutputCmplxParam(void* pObject, void* pSZFunct, 
          void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace) = 0;
  
      virtual int AXISCALL addFaultDetail(void* pObject, void* pSZFunct,
          void* pDelFunct, const AxisChar* pName, const AxisChar* pNamespace) = 0;
  
      /* Methods used to serialize arrays */
      virtual int AXISCALL serializeCmplxArray(const Axis_Array* pArray, 
          void* pSZFunct, void* pDelFunct, void* pSizeFunct, 
          const AxisChar* pName, const AxisChar* pNamespace)=0;
  
      virtual int AXISCALL serializeBasicArray
          (const Axis_Array* pArray, XSDTYPE nType, const AxisChar* pName)=0;
  
      /* Basic Type Serializing methods */
      virtual int AXISCALL serializeAsElement(const AxisChar* sName, 
          void* pValue, XSDTYPE type)=0;
  
      virtual int AXISCALL serializeAsAttribute(const AxisChar* sName, 
          const AxisChar* pNamespace, void* pValue, XSDTYPE type)=0;
  
      virtual void AXISCALL serialize(const char* pFirst, ...)=0;
  
      /* 
       * following two functions are needed by serializer 
       * functions of complex types for RPC style web services 
       */
      virtual void AXISCALL serializeStartElementOfType(const AxisChar* pName, 
          const AxisChar* pNamespace, const AxisChar* pPrefix)=0;
  
      virtual void AXISCALL serializeEndElementOfType(const AxisChar* pName)=0;
  
      /* Externalization of serializer API */
  
      /* Following functions need not be exposed. They are internal to the
  	 * Axis Engine - Commented by Susantha 02/07/2004
  
      virtual int setOutputStream(SOAPTransport* pStream)=0;
  
      virtual void markEndOfStream()=0;    
  
      virtual int init()=0;    
  
      virtual void setStyle(AXIS_BINDING_STYLE nStyle)=0;
  
      virtual AXIS_BINDING_STYLE getStyle()=0;
      */
  
      virtual PROVIDERTYPE getCurrentProviderType()=0;
  
      virtual void setCurrentProviderType(PROVIDERTYPE nType)=0;    
  
      virtual int addOutputAnyObject(AnyType* pAnyObject)=0;
  
      virtual int serializeAnyObject(AnyType* pAnyObject)=0;
  
      virtual int serializeAsChardata(void* pValue, XSDTYPE type)=0;
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif
  
  
  
  
  1.1                  ws-axis/c/include/axis/SoapEnvVersions.hpp
  
  Index: SoapEnvVersions.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   *
   *
   * @author Roshan Weerasuriya (roshan@opensource.lk, roshan@jkcs.slt.lk)
   *
   */
  
  /* SoapEnvVersions.h:*/
  
  #include "../server/GDefine.hpp"
  
  #ifdef WIN32
  #pragma warning (disable : 4786)
  #endif
  
  #ifndef __SOAPENVVERSIONS_H_OF_AXIS_INCLUDED___
  #define __SOAPENVVERSIONS_H_OF_AXIS_INCLUDED___
  
  /*
   * Here SKW stands for SoapKeyWord. This is a internal naming convension
   * for Axis C++.
   */
  typedef enum SOAP_WORDSTag 
  {
      SKW_ENVELOPE=0, /* this should always be 0 */
      SKW_HEADER,
      SKW_BODY,
      SKW_MUSTUNDERSTAND,
      SKW_ACTOR,
      SKW_ENCODING_STYLE,
      SKW_FAULT,
      SKW_FAULT_CODE,
      SKW_FAULT_STRING,
      SKW_FAULT_ACTOR,
      SKW_DETAIL,
      SKW_MULTIREF,
      
      SKW_TYPE,
      SKW_ARRAYTYPE,
      SKW_HREF,
      SKW_ID,
  
      SOAP_WORDS_LAST /*this should be the number of entries in this enum */
  } SOAP_WORDS;
  
  typedef enum SOAP_VERSIONTag 
  {
      SOAP_VER_1_1=0,
      SOAP_VER_1_2,
  
      VERSION_LAST
  } SOAP_VERSION;
  
  struct SoapEnvVersionsStruct 
  {    
      const AxisChar* pchNamespaceUri;
      const AxisChar* pchPrefix;
      const AxisChar* pchWords[SOAP_WORDS_LAST];
  };
  
  #endif
  
  
  
  
  1.1                  ws-axis/c/include/axis/TypeMapping.hpp
  
  Index: TypeMapping.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   */
  
  
  #ifdef WIN32
  #pragma warning (disable : 4786)
  #endif
  
  #if !defined(_TYPEMAPPING_H____OF_AXIS_INCLUDED_)
  #define _TYPEMAPPING_H____OF_AXIS_INCLUDED_
  
  #include "GDefine.hpp"
  #include <map>
  #include <string>
  
  typedef enum XSDTYPETag 
  { XSD_UNKNOWN=1, XSD_INT, XSD_FLOAT, XSD_STRING, XSD_LONG, XSD_SHORT, \
                  XSD_BYTE, XSD_UNSIGNEDLONG, \
                  XSD_BOOLEAN, XSD_UNSIGNEDINT, XSD_UNSIGNEDSHORT, \
                  XSD_UNSIGNEDBYTE, \
                  XSD_DOUBLE, XSD_DECIMAL, XSD_DURATION, \
                  XSD_DATETIME, XSD_TIME, XSD_DATE, \
                  XSD_YEARMONTH, XSD_YEAR, XSD_MONTHDAY, XSD_DAY, \
                  XSD_MONTH, XSD_HEXBINARY, \
                  XSD_BASE64BINARY, XSD_ANYURI, XSD_QNAME, XSD_NCNAME, XSD_NOTATION, \
                  XSD_INTEGER, \
                  XSD_ARRAY, USER_TYPE, ACCESSOR, XSD_NMTOKEN, XSD_ANY
  } XSDTYPE;
  
  AXIS_CPP_NAMESPACE_START
  
  using namespace std;
  
  /**
   *  @class TypeMapping
   *  @brief interface for the TypeMapping class.
   *
   *
   *  @author Susantha Kumara (skumara@virtusa.com)
   */
  
  class TypeMapping  
  {
  public:
      static XSDTYPE map(const AxisXMLCh* sType);
      static void initialize();
  
  #if (defined(AIX) || (defined(_MSC_VER) && _MSC_VER >= 1300) || defined( __OS400__ ) || defined(__sun))
      static std::map<std::AxisXMLString, XSDTYPE> m_sTypeMap;
  #else
      static std::map<const std::AxisXMLString, XSDTYPE> m_sTypeMap;
  #endif
      static volatile bool m_bInit;
      TypeMapping();
      virtual ~TypeMapping();
  
  };
  
  AXIS_CPP_NAMESPACE_END
  
  #endif
  
  
  
  1.1                  ws-axis/c/include/axis/WSDDDefines.hpp
  
  Index: WSDDDefines.hpp
  ===================================================================
  /*
   *   Copyright 2003-2004 The Apache Software Foundation.
   *
   *   Licensed under the Apache License, Version 2.0 (the "License");
   *   you may not use this file except in compliance with the License.
   *   You may obtain a copy of the License at
   *
   *       http://www.apache.org/licenses/LICENSE-2.0
   *
   *   Unless required by applicable law or agreed to in writing, software
   *   distributed under the License is distributed on an "AS IS" BASIS,
   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   *   See the License for the specific language governing permissions and
   *   limitations under the License.
   *
   *
   *
   * @author Susantha Kumara (skumara@virtusa.com)
   *
   */
  
  #if !defined(__WSDD_DEFINES_H__OF_AXIS_INCLUDEDED__)
  #define __WSDD_DEFINES_H__OF_AXIS_INCLUDEDED__
  
  typedef enum  
  {
      UNKNOWN_PROVIDER=0,
      C_RPC_PROVIDER,
      C_DOC_PROVIDER,
      CPP_RPC_PROVIDER,
      CPP_DOC_PROVIDER,
      COM_PROVIDER
  } PROVIDERTYPE;
  
  #endif
  
  
  
  

Mime
View raw message