/*
 *   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.");
    }
}

}