src/cbindings/IWrapperSoapSerializerC.cpp - axis-axis1-c - Git at Google

 /*
  *   Copyright 2003-2004 The Apache Software Foundation.
 // (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved
  *
  *   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.
  */

 // !!! This include file must be first thing in file !!!
 #include "../platforms/PlatformAutoSense.hpp"

 #include <axis/IWrapperSoapSerializer.hpp>
 #include <axis/AxisException.hpp>

 #include "../soap/SoapSerializer.h"
 #include "client/StubC.h"

 #include <axis/Axis.h>
 #include <axis/GDefine.h>
 #include <axis/AxisUserAPI.h>
 #include <axis/BasicNode.h>
 #include <axis/SoapEnvVersions.h>
 #include <axis/TypeMapping.h>
 #include <axis/WSDDDefines.h>
 #include <axis/IWrapperSoapSerializer.h>

 #include "../common/AxisTrace.h"

 AXIS_CPP_NAMESPACE_USE

 extern "C" {

 static void processException(void *ser, int exceptionCode, const char *whatString)
 {
     AXIS_EXCEPTION_HANDLER_FUNCT exceptionHandler = axiscAxisInvokeExceptionHandler;
     void *stubExceptionHandler;

     StubC *s = (StubC *)(((SoapSerializer *)ser)->getCStub());
     if (s)
     {
         if ((stubExceptionHandler = s->getCExceptionHandler()) != NULL)
             exceptionHandler = (AXIS_EXCEPTION_HANDLER_FUNCT)stubExceptionHandler;

         s->doNotPerformClientRequest = true;
     }

     exceptionHandler(exceptionCode, whatString, NULL, NULL);
 }

 AXISC_STORAGE_CLASS_INFO
 void axiscSoapSerializerDestroy(AXISCHANDLE wrapperSoapSerializer)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;

     try
     {
         delete sz;
     }
     catch ( AxisException& e  )
     {
         axiscAxisInvokeExceptionHandler(e.getExceptionCode(), e.what(), NULL, NULL);
     }
     catch ( ... )
     {
         axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL);
     }
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerCreateSoapMethod(AXISCHANDLE wrapperSoapSerializer,
                           const AxiscChar * sLocalName,
                           const AxiscChar * sURI)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         return sz->createSoapMethod(sLocalName,sURI);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerCreateSoapFault(AXISCHANDLE wrapperSoapSerializer,
                          const AxiscChar * sLocalName,
                          const AxiscChar * sURI,
                          const AxiscChar * sFaultCode,
                          const AxiscChar * sFaultString)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         return sz->createSoapFault(sLocalName,sURI,sFaultCode,sFaultString);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }


 AXISC_STORAGE_CLASS_INFO
 const AxiscChar * axiscSoapSerializerGetNamespacePrefix(AXISCHANDLE wrapperSoapSerializer,
                                                                 const AxiscChar * pNamespace,
                                                                 AxiscBool * blnIsNewPrefix)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;

     try
     {
         bool isNewPrefix = false;
         const AxiscChar * returnValue;

         if (blnIsNewPrefix)
         {
             returnValue = sz->getNamespacePrefix(pNamespace, isNewPrefix);
             *(blnIsNewPrefix) = (AxiscBool) isNewPrefix;
         }
         else
             returnValue = sz->getNamespacePrefix(pNamespace);

         return returnValue;
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return (const AxiscChar *)NULL;
 }

 AXISC_STORAGE_CLASS_INFO
 void axiscSoapSerializerRemoveNamespacePrefix(AXISCHANDLE wrapperSoapSerializer,
                                 const AxiscChar * pNamespace)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;

     try
     {
         sz->removeNamespacePrefix(pNamespace);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerAddOutputParam(AXISCHANDLE wrapperSoapSerializer,
                         const AxiscChar * pchName,
                         void * pValue,
                         AXISC_XSDTYPE type)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         return sz->addOutputParam(pchName,pValue,(XSDTYPE)type);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerAddOutputCmplxArrayParam(AXISCHANDLE wrapperSoapSerializer,
                                   const Axisc_Array * pArray,
                                   void * pSZFunct,
                                   void * pDelFunct,
                                   const AxiscChar * pName,
                                   const AxiscChar * pNamespace)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         // Need to convert C-style array to C++-style array before calling serialization method.
         Axis_Array objArray;
         if (pArray)
             objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type);

         return sz->addOutputCmplxArrayParam((const Axis_Array*)&objArray,pSZFunct,pDelFunct,pName,pNamespace);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerAddOutputBasicArrayParam(AXISCHANDLE wrapperSoapSerializer,
                                   const Axisc_Array * pArray,
                                   AXISC_XSDTYPE nType,
                                   const AxiscChar * pName)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         // Need to convert C-style array to C++-style array before calling serialization method.
         Axis_Array objArray;
         if (pArray)
             objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type);

         return sz->addOutputBasicArrayParam((const Axis_Array*)&objArray,(XSDTYPE)nType,pName);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerAddOutputCmplxParam(AXISCHANDLE wrapperSoapSerializer,
                              void * pObject,
                              void * pSZFunct,
                              void * pDelFunct,
                              const AxiscChar * pName,
                              const AxiscChar * pNamespace)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         return sz->addOutputCmplxParam(pObject,pSZFunct,pDelFunct,pName,pNamespace);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerAddFaultDetail(AXISCHANDLE wrapperSoapSerializer,
                         void * pObject,
                         void * pSZFunct,
                         void * pDelFunct,
                         const AxiscChar * pName,
                         const AxiscChar * pNamespace)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         return sz->addFaultDetail(pObject,pSZFunct,pDelFunct,pName,pNamespace);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerSerializeCmplxArray(AXISCHANDLE wrapperSoapSerializer,
                              const Axisc_Array * pArray,
                              void * pSZFunct,
                              void * pDelFunct,
                              const AxiscChar * pName,
                              const AxiscChar * pNamespace)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         // Need to convert C-style array to C++-style array before calling serialization method.
         Axis_Array objArray;
         if (pArray)
             objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type);

         return sz->serializeCmplxArray((const Axis_Array*)&objArray,pSZFunct,pDelFunct,pName,pNamespace);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerSerializeBasicArray(AXISCHANDLE wrapperSoapSerializer,
                              const Axisc_Array * pArray,
                              const AxiscChar * pNamespace,
                              AXISC_XSDTYPE nType,
                              const AxiscChar * pName)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         // Need to convert C-style array to C++-style array before calling serialization method.
         Axis_Array objArray;
         if (pArray)
             objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type);

         // Serialize
         return sz->serializeBasicArray((const Axis_Array*)&objArray,pNamespace,(XSDTYPE)nType,pName);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerSerializeAsElement(AXISCHANDLE wrapperSoapSerializer,
                             const AxiscChar * sName,
                             const AxiscChar * pNamespace,
                             void * pValue, AXISC_XSDTYPE type)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         // Some elements (e.g. xsd__hexBinary, base64Binary) differ in how C++ defines
         // the types and how C defines the types, in those cases we need to create
         // the correct type that the engine is expecting.
         switch (type)
         {
             case axiscpp::XSD_HEXBINARY:
             {
                 xsdc__hexBinary *pVal = (xsdc__hexBinary *)pValue;
                 xsd__hexBinary pValObject;
                 pValObject.set(pVal->__ptr, pVal->__size);
                 if (pNamespace)
                    return sz->serializeAsElement(sName,pNamespace,&pValObject,(XSDTYPE)type);
                 else
                    return sz->serializeAsElement(sName,&pValObject,(XSDTYPE)type);
             }
             case axiscpp::XSD_BASE64BINARY:
             {
                 xsdc__base64Binary *pVal = (xsdc__base64Binary *)pValue;
                 xsd__base64Binary pValObject;
                 pValObject.set(pVal->__ptr, pVal->__size);
                 if (pNamespace)
                    return sz->serializeAsElement(sName,pNamespace,&pValObject,(XSDTYPE)type);
                 else
                    return sz->serializeAsElement(sName,&pValObject,(XSDTYPE)type);
             }
             default:
             {
                 if (pNamespace)
                    return sz->serializeAsElement(sName,pNamespace,pValue,(XSDTYPE)type);
                 else
                    return sz->serializeAsElement(sName,pValue,(XSDTYPE)type);
             }
         }
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerSerializeAsAttribute(AXISCHANDLE wrapperSoapSerializer,
                               const AxiscChar * sName,
                               const AxiscChar * pNamespace,
                               void * pValue,
                               AXISC_XSDTYPE type)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         return sz->serializeAsAttribute(sName,pNamespace,pValue,(XSDTYPE)type);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 void axiscSoapSerializerSerializeStartElementOfType(AXISCHANDLE wrapperSoapSerializer,
                                       const AxiscChar * pName,
                                       const AxiscChar * pNamespace,
                                       const AxiscChar * pPrefix)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return;

     try
     {
         sz->serializeStartElementOfType(pName,pNamespace,pPrefix);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }
 }

 AXISC_STORAGE_CLASS_INFO
 void axiscSoapSerializerSerializeEndElementOfType(AXISCHANDLE wrapperSoapSerializer,
                                     const AxiscChar * pName)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return;

     try
     {
         sz->serializeEndElementOfType(pName);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }
 }

 AXISC_STORAGE_CLASS_INFO
 AXISC_PROVIDERTYPE axiscSoapSerializerGetCurrentProviderType(AXISCHANDLE wrapperSoapSerializer)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;

     try
     {
         return (AXISC_PROVIDERTYPE)(sz->getCurrentProviderType());
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return ::UNKNOWN_PROVIDER;
 }

 AXISC_STORAGE_CLASS_INFO
 void axiscSoapSerializerSetCurrentProviderType(AXISCHANDLE wrapperSoapSerializer,
                                  AXISC_PROVIDERTYPE nType)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;

     try
     {
         sz->setCurrentProviderType((PROVIDERTYPE)nType);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerAddOutputAnyObject(AXISCHANDLE wrapperSoapSerializer,
                             AxiscAnyType * pAnyObject)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         AnyType objAnyType;

         if (pAnyObject && pAnyObject->_size > 0)
         {
             objAnyType._size  = pAnyObject->_size;
             objAnyType._array = pAnyObject->_array;
         }

         int returnCode = sz->addOutputAnyObject(&objAnyType);

         // Need to reset object so destructors do not free memory.
         objAnyType._size  = 0;
         objAnyType._array = NULL;

         return returnCode;
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerSerializeAnyObject(AXISCHANDLE wrapperSoapSerializer,
                             AxiscAnyType * pAnyObject)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         AnyType objAnyType;

         if (pAnyObject && pAnyObject->_size > 0)
         {
             objAnyType._size  = pAnyObject->_size;
             objAnyType._array = pAnyObject->_array;
         }

         int returnCode = sz->serializeAnyObject(&objAnyType);

         // Need to reset object so destructors do not free memory.
         objAnyType._size  = 0;
         objAnyType._array = NULL;

         return returnCode;
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 int axiscSoapSerializerSerializeAsChardata(AXISCHANDLE wrapperSoapSerializer,
                              void * pValue,
                              AXISC_XSDTYPE type)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return AXISC_FAIL;

     try
     {
         return sz->serializeAsChardata(pValue,(XSDTYPE)type);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return AXISC_FAIL;
 }

 AXISC_STORAGE_CLASS_INFO
 void axiscSoapSerializerAddAttachment(AXISCHANDLE wrapperSoapSerializer,
                         const AxiscChar * achId,
                         AXISCHANDLE objAttach)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return;

     try
     {
         sz->addAttachment(achId,(ISoapAttachment*)objAttach);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }
 }

 AXISC_STORAGE_CLASS_INFO
 void axiscSoapSerializerAddAttachmentBody(AXISCHANDLE wrapperSoapSerializer,
                             const AxiscChar * achId,
                             xsdc__base64Binary * pAttchBody)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return;

     try
     {
         sz->addAttachmentBody(achId,(xsd__base64Binary*)pAttchBody);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }
 }

 AXISC_STORAGE_CLASS_INFO
 void axiscSoapSerializerAddAttachmentHeader(AXISCHANDLE wrapperSoapSerializer,
                               const AxiscChar * achId,
                               const AxiscChar * achHeaderName,
                               const AxiscChar * achHeaderValue)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return;

     try
     {
         sz->addAttachmentHeader(achId,achHeaderName,achHeaderValue);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }
 }

 AXISC_STORAGE_CLASS_INFO
 AXISCHANDLE axiscSoapSerializerCreateSoapAttachmentSoapAttachment(AXISCHANDLE wrapperSoapSerializer)
 {
     IWrapperSoapSerializer *sz = (IWrapperSoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return (AXISCHANDLE)NULL;

     try
     {
         return (AXISCHANDLE)(sz->createSoapAttachment());
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }

     return (AXISCHANDLE)NULL;
 }

 AXISC_STORAGE_CLASS_INFO
 void axiscSoapSerializerSerialize(AXISCHANDLE wrapperSoapSerializer,
                                   const char *pFirst,
                                   ...)
 {
     SoapSerializer *sz = (SoapSerializer*)wrapperSoapSerializer;
     StubC *s = (StubC *)(((SoapSerializer *)sz)->getCStub());
     if (s && s->doNotPerformClientRequest)
         return;

     try
     {
         va_list args;

         va_start( args, pFirst);
         sz->serializeVargs(pFirst, args);
         va_end( args);
     }
     catch ( AxisException& e  )
     {
         processException(sz, e.getExceptionCode(), e.what());
     }
     catch ( ... )
     {
         processException(sz, -1, "Unrecognized exception thrown.");
     }
 }

 }
	/*
	* Copyright 2003-2004 The Apache Software Foundation.
	// (c) Copyright IBM Corp. 2004, 2005 All Rights Reserved
	*
	* 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.
	*/

	// !!! This include file must be first thing in file !!!
	#include "../platforms/PlatformAutoSense.hpp"

	#include <axis/IWrapperSoapSerializer.hpp>
	#include <axis/AxisException.hpp>

	#include "../soap/SoapSerializer.h"
	#include "client/StubC.h"

	#include <axis/Axis.h>
	#include <axis/GDefine.h>
	#include <axis/AxisUserAPI.h>
	#include <axis/BasicNode.h>
	#include <axis/SoapEnvVersions.h>
	#include <axis/TypeMapping.h>
	#include <axis/WSDDDefines.h>
	#include <axis/IWrapperSoapSerializer.h>

	#include "../common/AxisTrace.h"

	AXIS_CPP_NAMESPACE_USE

	extern "C" {

	static void processException(void ser, int exceptionCode, const char whatString)
	{
	AXIS_EXCEPTION_HANDLER_FUNCT exceptionHandler = axiscAxisInvokeExceptionHandler;
	void *stubExceptionHandler;

	StubC s = (StubC )(((SoapSerializer *)ser)->getCStub());
	if (s)
	{
	if ((stubExceptionHandler = s->getCExceptionHandler()) != NULL)
	exceptionHandler = (AXIS_EXCEPTION_HANDLER_FUNCT)stubExceptionHandler;

	s->doNotPerformClientRequest = true;
	}

	exceptionHandler(exceptionCode, whatString, NULL, NULL);
	}

	AXISC_STORAGE_CLASS_INFO
	void axiscSoapSerializerDestroy(AXISCHANDLE wrapperSoapSerializer)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;

	try
	{
	delete sz;
	}
	catch ( AxisException& e )
	{
	axiscAxisInvokeExceptionHandler(e.getExceptionCode(), e.what(), NULL, NULL);
	}
	catch ( ... )
	{
	axiscAxisInvokeExceptionHandler(-1, "Unrecognized exception thrown.", NULL, NULL);
	}
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerCreateSoapMethod(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * sLocalName,
	const AxiscChar * sURI)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	return sz->createSoapMethod(sLocalName,sURI);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerCreateSoapFault(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * sLocalName,
	const AxiscChar * sURI,
	const AxiscChar * sFaultCode,
	const AxiscChar * sFaultString)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	return sz->createSoapFault(sLocalName,sURI,sFaultCode,sFaultString);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}


	AXISC_STORAGE_CLASS_INFO
	const AxiscChar * axiscSoapSerializerGetNamespacePrefix(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * pNamespace,
	AxiscBool * blnIsNewPrefix)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;

	try
	{
	bool isNewPrefix = false;
	const AxiscChar * returnValue;

	if (blnIsNewPrefix)
	{
	returnValue = sz->getNamespacePrefix(pNamespace, isNewPrefix);
	*(blnIsNewPrefix) = (AxiscBool) isNewPrefix;
	}
	else
	returnValue = sz->getNamespacePrefix(pNamespace);

	return returnValue;
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return (const AxiscChar *)NULL;
	}

	AXISC_STORAGE_CLASS_INFO
	void axiscSoapSerializerRemoveNamespacePrefix(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * pNamespace)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;

	try
	{
	sz->removeNamespacePrefix(pNamespace);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerAddOutputParam(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * pchName,
	void * pValue,
	AXISC_XSDTYPE type)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	return sz->addOutputParam(pchName,pValue,(XSDTYPE)type);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerAddOutputCmplxArrayParam(AXISCHANDLE wrapperSoapSerializer,
	const Axisc_Array * pArray,
	void * pSZFunct,
	void * pDelFunct,
	const AxiscChar * pName,
	const AxiscChar * pNamespace)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	// Need to convert C-style array to C++-style array before calling serialization method.
	Axis_Array objArray;
	if (pArray)
	objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type);

	return sz->addOutputCmplxArrayParam((const Axis_Array*)&objArray,pSZFunct,pDelFunct,pName,pNamespace);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerAddOutputBasicArrayParam(AXISCHANDLE wrapperSoapSerializer,
	const Axisc_Array * pArray,
	AXISC_XSDTYPE nType,
	const AxiscChar * pName)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	// Need to convert C-style array to C++-style array before calling serialization method.
	Axis_Array objArray;
	if (pArray)
	objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type);

	return sz->addOutputBasicArrayParam((const Axis_Array*)&objArray,(XSDTYPE)nType,pName);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerAddOutputCmplxParam(AXISCHANDLE wrapperSoapSerializer,
	void * pObject,
	void * pSZFunct,
	void * pDelFunct,
	const AxiscChar * pName,
	const AxiscChar * pNamespace)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	return sz->addOutputCmplxParam(pObject,pSZFunct,pDelFunct,pName,pNamespace);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerAddFaultDetail(AXISCHANDLE wrapperSoapSerializer,
	void * pObject,
	void * pSZFunct,
	void * pDelFunct,
	const AxiscChar * pName,
	const AxiscChar * pNamespace)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	return sz->addFaultDetail(pObject,pSZFunct,pDelFunct,pName,pNamespace);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerSerializeCmplxArray(AXISCHANDLE wrapperSoapSerializer,
	const Axisc_Array * pArray,
	void * pSZFunct,
	void * pDelFunct,
	const AxiscChar * pName,
	const AxiscChar * pNamespace)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	// Need to convert C-style array to C++-style array before calling serialization method.
	Axis_Array objArray;
	if (pArray)
	objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type);

	return sz->serializeCmplxArray((const Axis_Array*)&objArray,pSZFunct,pDelFunct,pName,pNamespace);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerSerializeBasicArray(AXISCHANDLE wrapperSoapSerializer,
	const Axisc_Array * pArray,
	const AxiscChar * pNamespace,
	AXISC_XSDTYPE nType,
	const AxiscChar * pName)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	// Need to convert C-style array to C++-style array before calling serialization method.
	Axis_Array objArray;
	if (pArray)
	objArray.set((void **)pArray->m_Array, pArray->m_Size, (XSDTYPE)pArray->m_Type);

	// Serialize
	return sz->serializeBasicArray((const Axis_Array*)&objArray,pNamespace,(XSDTYPE)nType,pName);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerSerializeAsElement(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * sName,
	const AxiscChar * pNamespace,
	void * pValue, AXISC_XSDTYPE type)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	// Some elements (e.g. xsd__hexBinary, base64Binary) differ in how C++ defines
	// the types and how C defines the types, in those cases we need to create
	// the correct type that the engine is expecting.
	switch (type)
	{
	case axiscpp::XSD_HEXBINARY:
	{
	xsdc__hexBinary pVal = (xsdc__hexBinary )pValue;
	xsd__hexBinary pValObject;
	pValObject.set(pVal->__ptr, pVal->__size);
	if (pNamespace)
	return sz->serializeAsElement(sName,pNamespace,&pValObject,(XSDTYPE)type);
	else
	return sz->serializeAsElement(sName,&pValObject,(XSDTYPE)type);
	}
	case axiscpp::XSD_BASE64BINARY:
	{
	xsdc__base64Binary pVal = (xsdc__base64Binary )pValue;
	xsd__base64Binary pValObject;
	pValObject.set(pVal->__ptr, pVal->__size);
	if (pNamespace)
	return sz->serializeAsElement(sName,pNamespace,&pValObject,(XSDTYPE)type);
	else
	return sz->serializeAsElement(sName,&pValObject,(XSDTYPE)type);
	}
	default:
	{
	if (pNamespace)
	return sz->serializeAsElement(sName,pNamespace,pValue,(XSDTYPE)type);
	else
	return sz->serializeAsElement(sName,pValue,(XSDTYPE)type);
	}
	}
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerSerializeAsAttribute(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * sName,
	const AxiscChar * pNamespace,
	void * pValue,
	AXISC_XSDTYPE type)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	return sz->serializeAsAttribute(sName,pNamespace,pValue,(XSDTYPE)type);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	void axiscSoapSerializerSerializeStartElementOfType(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * pName,
	const AxiscChar * pNamespace,
	const AxiscChar * pPrefix)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return;

	try
	{
	sz->serializeStartElementOfType(pName,pNamespace,pPrefix);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}
	}

	AXISC_STORAGE_CLASS_INFO
	void axiscSoapSerializerSerializeEndElementOfType(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * pName)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return;

	try
	{
	sz->serializeEndElementOfType(pName);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}
	}

	AXISC_STORAGE_CLASS_INFO
	AXISC_PROVIDERTYPE axiscSoapSerializerGetCurrentProviderType(AXISCHANDLE wrapperSoapSerializer)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;

	try
	{
	return (AXISC_PROVIDERTYPE)(sz->getCurrentProviderType());
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return ::UNKNOWN_PROVIDER;
	}

	AXISC_STORAGE_CLASS_INFO
	void axiscSoapSerializerSetCurrentProviderType(AXISCHANDLE wrapperSoapSerializer,
	AXISC_PROVIDERTYPE nType)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;

	try
	{
	sz->setCurrentProviderType((PROVIDERTYPE)nType);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerAddOutputAnyObject(AXISCHANDLE wrapperSoapSerializer,
	AxiscAnyType * pAnyObject)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	AnyType objAnyType;

	if (pAnyObject && pAnyObject->_size > 0)
	{
	objAnyType._size = pAnyObject->_size;
	objAnyType._array = pAnyObject->_array;
	}

	int returnCode = sz->addOutputAnyObject(&objAnyType);

	// Need to reset object so destructors do not free memory.
	objAnyType._size = 0;
	objAnyType._array = NULL;

	return returnCode;
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerSerializeAnyObject(AXISCHANDLE wrapperSoapSerializer,
	AxiscAnyType * pAnyObject)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	AnyType objAnyType;

	if (pAnyObject && pAnyObject->_size > 0)
	{
	objAnyType._size = pAnyObject->_size;
	objAnyType._array = pAnyObject->_array;
	}

	int returnCode = sz->serializeAnyObject(&objAnyType);

	// Need to reset object so destructors do not free memory.
	objAnyType._size = 0;
	objAnyType._array = NULL;

	return returnCode;
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	int axiscSoapSerializerSerializeAsChardata(AXISCHANDLE wrapperSoapSerializer,
	void * pValue,
	AXISC_XSDTYPE type)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return AXISC_FAIL;

	try
	{
	return sz->serializeAsChardata(pValue,(XSDTYPE)type);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return AXISC_FAIL;
	}

	AXISC_STORAGE_CLASS_INFO
	void axiscSoapSerializerAddAttachment(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * achId,
	AXISCHANDLE objAttach)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return;

	try
	{
	sz->addAttachment(achId,(ISoapAttachment*)objAttach);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}
	}

	AXISC_STORAGE_CLASS_INFO
	void axiscSoapSerializerAddAttachmentBody(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * achId,
	xsdc__base64Binary * pAttchBody)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return;

	try
	{
	sz->addAttachmentBody(achId,(xsd__base64Binary*)pAttchBody);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}
	}

	AXISC_STORAGE_CLASS_INFO
	void axiscSoapSerializerAddAttachmentHeader(AXISCHANDLE wrapperSoapSerializer,
	const AxiscChar * achId,
	const AxiscChar * achHeaderName,
	const AxiscChar * achHeaderValue)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return;

	try
	{
	sz->addAttachmentHeader(achId,achHeaderName,achHeaderValue);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}
	}

	AXISC_STORAGE_CLASS_INFO
	AXISCHANDLE axiscSoapSerializerCreateSoapAttachmentSoapAttachment(AXISCHANDLE wrapperSoapSerializer)
	{
	IWrapperSoapSerializer sz = (IWrapperSoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return (AXISCHANDLE)NULL;

	try
	{
	return (AXISCHANDLE)(sz->createSoapAttachment());
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}

	return (AXISCHANDLE)NULL;
	}

	AXISC_STORAGE_CLASS_INFO
	void axiscSoapSerializerSerialize(AXISCHANDLE wrapperSoapSerializer,
	const char *pFirst,
	...)
	{
	SoapSerializer sz = (SoapSerializer)wrapperSoapSerializer;
	StubC s = (StubC )(((SoapSerializer *)sz)->getCStub());
	if (s && s->doNotPerformClientRequest)
	return;

	try
	{
	va_list args;

	va_start( args, pFirst);
	sz->serializeVargs(pFirst, args);
	va_end( args);
	}
	catch ( AxisException& e )
	{
	processException(sz, e.getExceptionCode(), e.what());
	}
	catch ( ... )
	{
	processException(sz, -1, "Unrecognized exception thrown.");
	}
	}

	}