You are viewing a plain text version of this content. The canonical link for it is here.
Posted to java-dev@axis.apache.org by wh...@apache.org on 2004/11/23 12:11:11 UTC
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
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