/*
 *   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.
 */

/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
/* NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE   */
/* ----------------------------------------------------------------   */
/* CHANGES TO hpp HEADER FILE MAY NEED TO BE PROPAGATED TO THE        */
/* C-EQUIVALENT HEADER FILE IN SUPPORT OF THE C-BINDING INTERFACES.   */
/* ----------------------------------------------------------------   */
/* NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE NOTE   */
/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */


#if !defined(_IWRAPPERSOAPSERIALIZER_H____OF_AXIS_INCLUDED_)
#define _IWRAPPERSOAPSERIALIZER_H____OF_AXIS_INCLUDED_

/**
 * @file IWrapperSoapSerializer.hpp
 */

#include <axis/AxisUserAPI.hpp>
#include <axis/TypeMapping.hpp>
#include <axis/WSDDDefines.hpp>
#include <axis/ISoapAttachment.hpp>
#include <stdarg.h>
#include <cctype>

/**
 *  @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:
    /**
     * Destructor
     */
    virtual ~IWrapperSoapSerializer(){};

    /**
     * Create new SOAP method, ie the first nested element within a SOAP Body.
     * 
     * @param sLocalName local name of the method
     * @param sURI namespace URI of the method
     * @return status
     * 
     * @deprecated Use other flavor of createSoapMethod
     */
    virtual int AXISCALL createSoapMethod(const AxisChar* sLocalName, 
                                          const AxisChar* sURI)=0;

    /**
     * Create new SOAP method, ie the first nested element within a SOAP Body.
     * 
     * @param sLocalName local name of the method
     * @param sURI namespace URI of the method
     * @param bIsWrapperStyle  whether the SOAP message to be generated is wrapper-style or not.
     * @return status
     * 
     */
    virtual int AXISCALL createSoapMethod(const AxisChar* sLocalName, 
                                          const AxisChar* sURI,
                                          bool  bIsWrapperStyle)=0;
    
    /**
     * Create a new SOAP Fault within the SOAP Body.
     * 
     * This creates a SOAP Fault with no detail element, this can be added later
     * using:
     * 
     * IWrapperSoapSerializer::addFaultDetail(const AxisChar*) for character detail, or
     * 
     * IWrapperSoapSerializer::addFaultDetail(void*, void*, void*, const AxisChar*, const AxisChar*) for complex detail
     * 
     * @param sLocalName local name for the SOAP Fault.
     * @param sURI namespace URI for the SOAP Fault.
     * @param sFaultCode fault code for the SOAP Fault.
     * @param sFaultString fault string for the SOAP Fault.
     * @return status
     */
    virtual int AXISCALL createSoapFault(const AxisChar* sLocalName, 
                                         const AxisChar* sURI, 
                                         const AxisChar* sFaultCode,
                                         const AxisChar* sFaultString)=0;

    /**
     * Returns the corrosponding namespace prefix.
     * @param pNamespace The namespace.
     * @return The corrosponding prefix.
     */
    virtual const AxisChar* AXISCALL getNamespacePrefix(const AxisChar* pNamespace)=0;
    
    /**
     * Returns the corrosponding namespace prefix. This method is 
     * called when the caller also wants to know whether this is a new 
     * namespace or not as appose to its overloaded other member.
     * @param pNamespace The namespace.
     * @param blnIsNewPrefix The boolean which behaves as 
     * an out parameter to indicate whether this is a new namespace or not.
     * @return The corrosponding prefix.
     */
    virtual const AxisChar* AXISCALL getNamespacePrefix(const AxisChar* pNamespace,
                                                        bool& blnIsNewPrefix)=0;
    
    /**
     * Remove the prefix for specified namespace.
     * @param pNamespace namespace URI for which the corresponding prefix will be removed.
     */
    virtual void AXISCALL removeNamespacePrefix(const AxisChar* pNamespace)=0;

    /**
     * Add a basic element, ie a SOAP element containing an XSD simple type,
     * to outgoing SOAP message.
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * See AxisUserAPI.hpp for full list of XSD built-in simple types.
     * 
     * @param pchName local name for SOAP element.
     * @param pValue value for element data.
     * @param type XSD type of data.
     * @return status
     */
    virtual int AXISCALL addOutputParam(const AxisChar* pchName, 
                                        void* pValue, 
                                        XSDTYPE type)=0;

    /**
     * Add an array of complex type to the outgoing SOAP message.
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * @param pArray Axis_Array containing complex type elements.
     * @param pSZFunct function pointer to complex type serialize method.
     * @param pDelFunct function pointer to complex type delete method.
     * @param pName local name for array elements.
     * @param pNamespace namespace URI for array elements.
     * @return status
     */
    virtual int AXISCALL addOutputCmplxArrayParam(const Axis_Array* pArray, 
                                                  void* pSZFunct, 
                                                  void* pDelFunct, 
                                                  const AxisChar* pName, 
                                                  const AxisChar* pNamespace)=0;

    /**
     * Add an array of basic type to outgoing SOAP message.
     * 
     * See AxisUserAPI.hpp for full list of XSD built-in simple types.
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * @param pArray Axis_Array containing basic type elements.
     * @param nType XSD type for data.
     * @param pName local name for array elements.
     * @return status
     */
    virtual int AXISCALL addOutputBasicArrayParam(const Axis_Array* pArray, 
                                                  XSDTYPE nType, 
                                                  const AxisChar* pName)=0;

    /**
     * Add a complex type element to the outgoing SOAP message.
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * @param pObject complex type object.
     * @param pSZFunct function pointer to complex type serialize method.
     * @param pDelFunct function pointer to complex type delete method.
     * @param pName local name for complex type element.
     * @param pNamespace namespace URI for complex type element.
     * @return status
     */
    virtual int AXISCALL addOutputCmplxParam(void* pObject, 
                                             void* pSZFunct,
                                             void* pDelFunct, 
                                             const AxisChar* pName, 
                                             const AxisChar* pNamespace) = 0;

    /**
     * Use this method to add complex detail to a SOAP Fault.
     * 
     * The SOAP fault must be created before using this method, by using: 
     * IWrapperSoapSerializer::createSoapFault(const AxisChar*, const AxisChar*, const AxisChar*, const AxisChar*)
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * @param pObject complex detail object.
     * @param pSZFunct function pointer to serialize method.
     * @param pDelFunct function pointer to delete method.
     * @param pName local name for detail element
     * @param pNamespace namespace URI for detail element.
     * @return status
     */
    virtual int AXISCALL addFaultDetail(void* pObject, 
                                        void* pSZFunct, 
                                        void* pDelFunct, 
                                        const AxisChar* pName, 
                                        const AxisChar* pNamespace) = 0;

    /**
     * Use this method to add simple, ie text, detail to a SOAP fault.
     * 
     * The SOAP fault must be created before using this method, by using: 
     * IWrapperSoapSerializer::createSoapFault(const AxisChar*, const AxisChar*, const AxisChar*, const AxisChar*)
     * 
     * @param pDetail The text to be used for the detail element of the SOAP fault.
     * @return indicates success or failure of adding fault detail
     */
    virtual int AXISCALL addFaultDetail( const AxisChar * pDetail) = 0;

    /**
     * Serialize an array of complex type to the outgoing SOAP message.
     * 
     * This method would normally be used by the serialize methods in complex types.
     * 
     * @param pArray Axis_Array containing complex type elements.
     * @param pSZFunct function pointer to complex type serialize method.
     * @param pDelFunct function pointer to complex type delete method.
     * @param pName local name for array elements.
     * @param pNamespace namespace URI for array elements.
     * @return status
     */
    virtual int AXISCALL serializeCmplxArray(const Axis_Array* pArray,
                                             void* pSZFunct, 
                                             void* pDelFunct, 
                                             const AxisChar* pName, 
                                             const AxisChar* pNamespace)=0;

    /**
     * Serialize an array of basic type to outgoing SOAP message.
     * 
     * See AxisUserAPI.hpp for full list of XSD built-in simple types.
     * 
     * This method would normally be used by the serialize methods in complex types.
     * 
     * @param pArray Axis_Array containing basic type elements.
     * @param nType XSD type for data.
     * @param pName local name for array elements.
     * @return status
     */
    virtual int AXISCALL serializeBasicArray(const Axis_Array* pArray, 
                                             XSDTYPE nType, 
                                             const AxisChar* pName)=0;

    /**
     * Serialize an array of basic type to outgoing SOAP message.
     * 
     * See AxisUserAPI.hpp for full list of XSD built-in simple types.
     * 
     * This method would normally be used by the serialize methods in complex types.
     * 
     * @param pArray Axis_Array containing basic type elements.
     * @param pNamespace namespace URI for array elements.
     * @param nType XSD type for data.
     * @param pName local name for array elements.
     * @return status
     */
    virtual int AXISCALL serializeBasicArray(const Axis_Array* pArray, 
                                             const AxisChar* pNamespace, 
                                             XSDTYPE nType, 
                                             const AxisChar* pName)=0;

    /**
     * Serialize a basic element, ie a SOAP element containing an XSD simple type,
     * to outgoing SOAP message.
     * 
     * This method would normally be used by the serialize methods in complex types.
     * 
     * See AxisUserAPI.hpp for full list of XSD built-in simple types.
     * 
     * @param sName local name for SOAP element.
     * @param pValue value for element data.
     * @param type XSD type of data.
     * @return status
     */
    virtual int AXISCALL serializeAsElement(const AxisChar* sName,
                                            void* pValue, 
                                            XSDTYPE type)=0;

    /**
     * Serialize a basic element, ie a SOAP element containing an XSD simple type,
     * to outgoing SOAP message.
     * 
     * This method would normally be used by the serialize methods in complex types.
     * 
     * See AxisUserAPI.hpp for full list of XSD built-in simple types.
     * 
     * @param sName local name for SOAP element.
     * @param pNamespace namespace URI for SOAP element
     * @param pValue value for element data.
     * @param type XSD type of data.
     * @return status
     */
    virtual int AXISCALL serializeAsElement(const AxisChar* sName, 
                                            const AxisChar* pNamespace,
                                            void* pValue, 
                                            XSDTYPE type)=0;

    /**
     * Serialize aa attribute to outgoing SOAP message.
     * 
     * This method would normally be used by the serialize methods in complex types.
     * 
     * See AxisUserAPI.hpp for full list of XSD built-in simple types.
     * 
     * @param sName local name for SOAP attribute.
     * @param pNamespace namespace URI for SOAP attribute.
     * @param pValue value for attribute data.
     * @param type XSD type of data.
     * @return status
     */
    virtual int AXISCALL serializeAsAttribute(const AxisChar* sName,
                                              const AxisChar* pNamespace, 
                                              void* pValue, 
                                              XSDTYPE type)=0;

    /**
     * Serialize an array of strings.
     * 
     * The strings will be serialized "as-is", no validation will take place.
     * Primary use is by the C-bindings interface.
     * 
     * @param pFirst first string to be serialized.
     * @param args ptr to va_list of strings to be serialized.
     */
    virtual void AXISCALL serializeVargs(const char* pFirst, va_list args)=0;
    
    /**
     * Serialize strings.  All arguments must be strings (char *).
     * The final argument must be NULL.
     * 
     * The strings will be serialized "as-is", no validation will take place.
     * 
     * @param pFirst first string to be serialized.
     */
    virtual void AXISCALL serialize(const char* pFirst, ...)=0;

    /**
     * Serialize start element tag for complex type.
     * This is only used for rpc/encoded style web services.
     * 
     * @param pName local name of element.
     * @param pNamespace namespace URI of element.
     * @param pPrefix prefix to be used with namespace URI.
     */
    virtual void AXISCALL serializeStartElementOfType(const AxisChar* pName, 
                                                      const AxisChar* pNamespace, 
                                                      const AxisChar* pPrefix)=0;

    /**
     * Serialize end element tag for complex type.
     * This is only used for rpc/encoded style web services.
     * 
     * @param pName local name of element.
     */
    virtual void AXISCALL serializeEndElementOfType(const AxisChar* pName)=0;

    /**
     * Get and return the current provider type being used by the SOAP Serializer.
     * 
     * @return provider type.
     */
    virtual PROVIDERTYPE getCurrentProviderType()=0;

    /**
     * Set the current provider type to be used by the SOAP serializer.
     * 
     * @param nType provider type to be used.
     */
    virtual void setCurrentProviderType(PROVIDERTYPE nType)=0;    

    /**
     * Add an AnyType object to the outgoing SOAP message.
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * @param pAnyObject an AnyType object containing valid XML.
     * @return status.
     */
    virtual int addOutputAnyObject(AnyType* pAnyObject)=0;

    /**
     * Serialize an AnyType object to the outgoing SOAP message.
     * 
     * This method would normally be used by the serialize methods in complex types.
     * 
     * @param pAnyObject an AnyType object containing valid XML.
     * @return status.
     */
    virtual int serializeAnyObject(AnyType* pAnyObject)=0;

    /**
     * Serialize an XML simple type.  Care must be taken to ensure this is correctly
     * placed within an element or attribute.
     * 
     * This method would normally be used by the serialize methods in complex types.
     * 
     * @param pValue value to be serialized.
     * @param type XSD type of the data.
     * @return status
     */
    virtual int serializeAsChardata(void* pValue, 
                                    XSDTYPE type)=0;

    /**
     * Add an attachment to the outgoing SOAP message.
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * @param achId attachment ID.
     * @param objAttach SOAP attachment.
     */
    virtual void addAttachment(const AxisChar* achId, 
                               ISoapAttachment* objAttach)=0;

    /**
     * Add attachments to the outgoing SOAP message.
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * @param pAttach array of ISoapAttachment
     * @param iAttchArraySize number of attachments to be added.
     */
    virtual void addAttachments(ISoapAttachment** pAttach, 
                                int iAttchArraySize)=0;

    /**
     * Add attachment body to the outgoing SOAP message.
     * If an attachment already exists for the given ID the body will be added to it,
     * otherwise a new attachment will be created.
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * @param achId attachment ID.
     * @param pAttchBody body for SOAP attachment.
     */
    virtual void addAttachmentBody(const AxisChar* achId, 
                                   xsd__base64Binary* pAttchBody)=0;

    /**
     * Add attachment header to the outgoing SOAP message.
     * If an attachment already exists for the given ID the header will be added to it,
     * otherwise a new attachement will be created.
     * 
     * This method would normally be used in client stubs or service wrappers.
     * 
     * @param achId attachment ID.
     * @param achHeaderName attachment header name.
     * @param achHeaderValue attachment header value.
     */
    virtual void addAttachmentHeader(const AxisChar* achId, 
                                     const AxisChar* achHeaderName, 
                                     const AxisChar* achHeaderValue)=0;

    /**
     * creates and returns a SoapAttachment object to the caller of this methods.
     *  The user can use this object and fill in the attachment details. This
     *  method doesn't add the created SoapAttachment object to the Serializer.
     *  The user will have to add this object explictly by calling the addAttachment 
     *  method of the IWrapperSoapSerializer interface   
     */
    virtual ISoapAttachment* createSoapAttachment()=0;

    /**
     * This method will clear up all the current out params in preparation of a 
     * new method call
     */
    virtual void reset() = 0;
};

AXIS_CPP_NAMESPACE_END

#endif