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

/**
 * @file AxisException.hpp
 *
 */
 
/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
/* 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   */
/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */

#ifndef __AXISEXCEPTION_H_OF_AXIS_INCLUDED_
#define __AXISEXCEPTION_H_OF_AXIS_INCLUDED_

#include <axis/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.
 */
#define CLIENT_FAULT_OFFSET      0x0
#define SERVER_FAULT_OFFSET      0x1000
#define SOAP_FAULT_OFFSET        0x2000
#define ENGINE_FAULT_OFFSET      0x3000
#define WSDD_FAULT_OFFSET        0x4000
#define TRANSPORT_FAULT_OFFSET   0x5000
#define CONFIG_FAULT_OFFSET      0x6000
#define AXISC_FAULT_OFFSET       0x7000

/**
 * @enum AXISC_EXCEPTIONS
 * Enumeration of exception codes used by AxisException
 */
typedef enum 
{
    /*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 related
     *    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 related
     *    exception
     *TRANSPORT that comes next to CLIENT/SERVER means this is a transport related
     *    exception
     *CONFIG that comes next to CLIENT/SERVER means this is a axisc++ configuration
     *    related exception
     *AXISC ?
     */
    /* SOAP faults */
        /** AxisSoapException:Soap Version mismatch fault occurred */
/*0*/    SOAP_VERSION_MISMATCH, 
        /** AxisSoapException:Soap Must understand fault occurred */
/*1*/    SOAP_MUST_UNDERSTAND,    

    /* Client faults */
        /**
         * AxisSoapException:Received message is incomplete
         */
/*2*/    CLIENT_SOAP_MESSAGE_INCOMPLETE,
        /**
         * AxisSoapException:Soap action is empty
         */
/*3*/    CLIENT_SOAP_SOAP_ACTION_EMTPY,
        /**
         * AxisSoapException:Received content is faulty
         */
/*4*/    CLIENT_SOAP_SOAP_CONTENT_ERROR,
        /**
         * AxisSoapException:Request method is not a soap method
         */
/*5*/    CLIENT_SOAP_NO_SOAP_METHOD,
        /**
         * AxisSoapException:Content is not a valid soap message
         */
/*6*/    CLIENT_SOAP_CONTENT_NOT_SOAP,
        /**
         * AxisWsddException:Requested service not found
         */
/*7*/    CLIENT_WSDD_SERVICE_NOT_FOUND,
        /**
         * AxisWsddException:Requested method is not allowed
         */
/*8*/    CLIENT_WSDD_METHOD_NOT_ALLOWED,
        /**
         * AxisWsddException: Parameter type mismatch
         */
/*9*/    CLIENT_WSDD_PARA_TYPE_MISMATCH,
        /**
         * 
         */
/*10*/   CLIENT_ENGINE_CLIENT_HANDLER_FAILED,
        /**
         * HTTPTransportException:Generic client transport exception
         */
/*11*/   CLIENT_TRANSPORT_EXCEPTION,
        /**
         * HTTPTransportException:Client failed to open connection to server
         */
/*12*/   CLIENT_TRANSPORT_OPEN_CONNECTION_FAILED,
        /**
         * HTTPTransportException:Client attempted to use SSL functions without the proper prerquistes
         */
/*13*/   CLIENT_TRANSPORT_TYPE_MISMATCH,
        /**
         * CLIENT_TRANSPORT_HAS_NO_UNSECURE_TRANSPORT_LAYER
         */
/*14*/   CLIENT_TRANSPORT_HAS_NO_UNSECURE_TRANSPORT_LAYER,
        /**
         * HTTPTransportException:Client attempted to use secure transport (https) without an SSL layer
         */
/*15*/   CLIENT_TRANSPORT_HAS_NO_SECURE_TRANSPORT_LAYER,
        /**
         * 
         */
/*16*/   CLIENT_SSLCHANNEL_RECEPTION_EXCEPTION,
        /**
         * 
         */
/*17*/   CLIENT_SSLCHANNEL_SENDING_EXCEPTION,
        /**
         * 
         */
/*18*/   CLIENT_SSLCHANNEL_CHANNEL_INIT_ERROR,
        /**
         * 
         */
/*19*/   CLIENT_SSLCHANNEL_SOCKET_CREATE_ERROR,
        /**
         * 
         */
/*20*/   CLIENT_SSLCHANNEL_SOCKET_CONNECT_ERROR,
        /**
         * 
         */
/*21*/   CLIENT_SSLCHANNEL_INVALID_SOCKET_ERROR,
        /**
         * Check implementation specific error message
         */
/*22*/   CLIENT_SSLCHANNEL_CONTEXT_CREATE_ERROR,
        /**
         * Check implementation specific error message
         */
/*23*/   CLIENT_SSLCHANNEL_ERROR,
        /**
         * AxisSoapException:Content is not unique within the MIME message
         */
/*24*/   CLIENT_MIME_CONTENT_ID_NOT_UNIQUE,

    /* Server faults */
        /**
         * SERVER_ENGINE_EXCEPTION
         */
/*25*/    SERVER_ENGINE_EXCEPTION,
        /**
         * AxisEngineException:Could not load service
         */
/*26*/    SERVER_ENGINE_COULD_NOT_LOAD_SRV,
        /**
         * AxisEngineException:Could not load handler
         */
/*27*/    SERVER_ENGINE_COULD_NOT_LOAD_HDL,
        /**
         * DLOPEN FAILED in loading transport library
         */
/*28*/    SERVER_ENGINE_LOADING_TRANSPORT_FAILED,
        /**
         * DLOPEN FAILED in loading parser library
         */
/*29*/    SERVER_ENGINE_LOADING_PARSER_FAILED,
        /**
         * AxisEngineException:Handler failed
         */
/*30*/    SERVER_ENGINE_HANDLER_FAILED,
        /**
         * AxisEngineException:Web Service failed
         */
/*31*/    SERVER_ENGINE_WEBSERVICE_FAILED,
        /**
         * AxisEngineException:Handler initialization failed
         */
/*32*/    SERVER_ENGINE_HANDLER_INIT_FAILED,
        /**
         * AxisEngineException:Handler creation failed
         */
/*33*/    SERVER_ENGINE_HANDLER_CREATION_FAILED,
        /**
         * AxisEngineException:Library loading failed
         */
/*34*/    SERVER_ENGINE_LIBRARY_LOADING_FAILED,
        /**
         * AxisEngineException:Handler is not loaded
         */
/*35*/    SERVER_ENGINE_HANDLER_NOT_LOADED,
        /**
         * AxisEngineException:Handler is being used
         */
/*36*/    SERVER_ENGINE_HANDLER_BEING_USED,
        /**
         * AxisEngineException:Get handler failed
         */
/*37*/    SERVER_ENGINE_GET_HANDLER_FAILED,
        /**
         * AxisEngineException:Wrong handler type
         */
/*38*/    SERVER_ENGINE_WRONG_HANDLER_TYPE,
        /**
         * AxisConfigException:Unknown Axis C++ Configuration Exception
         */
/*39*/    SERVER_CONFIG_EXCEPTION,
        /**
         * AxisConfigException:Transport layer is not configured properly
         */
/*40*/    SERVER_CONFIG_TRANSPORT_CONF_FAILED,
        /**
         * AxisConfigException:Library path is empty(Not in server.wsdd file)
         */
/*41*/    SERVER_CONFIG_LIBRARY_PATH_EMPTY,
        /**
         * AxisWsddException:WSDD loading fail
         */
/*42*/    SERVER_WSDD_FILE_NOT_FOUND,
        /**
         * AxisWsddException:Unknown wsdd exception
         */
/*43*/    SERVER_WSDD_EXCEPTION,
        /**
         * AxisWsddException:No handlers configured in server.wsdd
         */
/*44*/    SERVER_WSDD_NO_HANDLERS_CONFIGURED,
        /**
         * AxisSoapException:Unknown Soap Exception
         */
/*45*/    SERVER_SOAP_EXCEPTION,
        /**
         * 
         */
/*46*/    SERVER_TRANSPORT_EXCEPTION,
        /**
         * HTTPTransportException:Problem occurred when receiving the stream
         */
/*47*/    SERVER_TRANSPORT_RECEPTION_EXCEPTION,
        /**
         * HTTPTransportException:Problem occurred when sending the stream
         */
/*48*/    SERVER_TRANSPORT_SENDING_EXCEPTION,
        /**
         * HTTPTransportException:HTTP Error, cannot process response message
         */
/*49*/    SERVER_TRANSPORT_PROCESS_EXCEPTION,
        /**
         * HTTPTransportException:Unknow HTTP response, cannot process response message
         */
/*50*/    SERVER_TRANSPORT_UNKNOWN_HTTP_RESPONSE,
        /**
         * HTTPTransportException:HTTP transport error
         */
/*51*/    SERVER_TRANSPORT_HTTP_EXCEPTION,
        /**
         * HTTPTransportException:Unexpected string received.
         * Most probably server returned an empty stream
         */
/*52*/    SERVER_TRANSPORT_UNEXPECTED_STRING,
        /**
         * HTTPTransportException:Cannot initialize a channel to the remote end
         */
/*53*/    SERVER_TRANSPORT_CHANNEL_INIT_ERROR,
        /**
         * AxisTransportException:Sockets error Couldn't create socket
         */
/*54*/    SERVER_TRANSPORT_SOCKET_CREATE_ERROR,
        /**
         * AxisTransportException:Cannot open a channel to the remote end, shutting down the channel
         */
/*55*/    SERVER_TRANSPORT_SOCKET_CONNECT_ERROR,
        /**
         * AxisTransportException:Invalid socket. Socket may not be open
         */
/*56*/    SERVER_TRANSPORT_INVALID_SOCKET,
        /**
         * AxisTransportException:Output streaming error on Channel while writing data
         */
/*57*/    SERVER_TRANSPORT_OUTPUT_STREAMING_ERROR,
        /**
         * AxisTransportException:Input streaming error while getting data
         */
/*58*/    SERVER_TRANSPORT_INPUT_STREAMING_ERROR,
        /**
         * AxisTransportException:Channel error while waiting for timeout
         */
/*59*/    SERVER_TRANSPORT_TIMEOUT_EXCEPTION,
        /**
         * AxisTransportException:Channel error connection timeout before receiving
         */
/*60*/    SERVER_TRANSPORT_TIMEOUT_EXPIRED,
        /**
         * See implementation specific error message
         */
/*61*/    SERVER_TRANSPORT_LOADING_SSLCHANNEL_FAILED,
        /**
         * DLOPEN FAILED in loading channel library
         */
/*62*/    SERVER_TRANSPORT_LOADING_CHANNEL_FAILED,
        /**
         * AxisTransportException:Transport buffer is empty
         */
/*63*/    SERVER_TRANSPORT_BUFFER_EMPTY,
        /**
         * AxisParseException:Buffer received from the parser is empty.  
         */
/*64*/    SERVER_PARSE_BUFFER_EMPTY,
        /**
         * AxisParseException:XML_STATUS_ERROR thrown from parser.  
         */
/*65*/    SERVER_PARSE_PARSER_FAILED, 
        /**
         * AxisParseException:Error when getting the byte stream from the transport.  
         */
/*66*/    SERVER_PARSE_TRANSPORT_FAILED,
        /**
         * This is a testing error
         */
/*67*/    SERVER_TEST_EXCEPTION,
        /**
         * Unknown error
         */
/*68*/    SERVER_UNKNOWN_ERROR,
        /**
         * AxisEngineException:Engine cannot be initialized as both client and server
         */
/*69*/    SERVER_CLIENT_ENGINE_MISMATCH,

    /* AXIS C faults */
    /*Following exceptions are not releated to soap faults
     */
        /**
         * A service has thrown an exception. see detail 
         */
/*70*/    AXISC_SERVICE_THROWN_EXCEPTION,
        /**
         * 
         */
/*71*/    AXISC_UNKNOWN_ELEMENT_EXCEPTION,
        /**
         * Cannot deserialize the requested element.
         * This may indicate a fault has been received.
         */
/*72*/    AXISC_NODE_VALUE_MISMATCH_EXCEPTION,
        /**
         * 
         */
/*73*/    AXISC_READ_CONF_EXCEPTION,

    /* CONFIG faults */
    /*Following exceptions are related to configuration faults
     */
        /**
         * AxisConfigException:configuration defaults have already been set
         */
/*74*/    CONFIG_DEFAULTS_ALREADY_SET,

    /**
     * HTTPTransportException: Redirect received
     */
/*75*/   SERVER_TRANSPORT_REDIRECT_RECEIVED,

    /*
     * 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.
     */
/*76*/    FAULT_LAST
} AXISC_EXCEPTIONS;

/**
 *   @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():m_iExceptionCode(0), m_sMessage("") { }

    /** 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 iExceptionCode Exception code which is defined in the AxisException.h file,
      *  under AXISC_EXCEPTIONS type.
      * @param pcMessage A char pointer that will point to an exception message.
      * 
      * Example usage:
      * <pre>
      * throw AxisException(AXISC_NODE_VALUE_MISMATCH_EXCEPTION, 
      *                     "Some additional exception info");
        </pre>
      */
    AxisException(int iExceptionCode, const char* pcMessage = NULL):m_iExceptionCode(iExceptionCode)
    {
        setMessage(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 e An exception class derived from std::exception
      *
      * Example usage:
      * <pre>
      * throw AxisException(std::bad_alloc);
      * </pre>
      */
    AxisException(const AxisException& e):m_iExceptionCode(e.m_iExceptionCode)
    {
        setMessage(e.m_sMessage.c_str());
    }
    
    /** Destructor */
    virtual ~AxisException() throw() { }

    /**
     *  This method is defined in std::exception. AxisException and derived
     * classes will override this to print exception messages
     * 
     * @return Exception message
     */
    virtual const char* what() const throw() { return m_sMessage.c_str(); }

    /**
     * This can be called to get the exception code.
     *
     * @return Exception code
     */
    virtual int getExceptionCode() const { return m_iExceptionCode; }

    /**
     * This can be called to set the exception code
     * 
     * @param exceptionCode for this exception.
     */
    void setExceptionCode(int exceptionCode) { m_iExceptionCode = exceptionCode;}

    /**
     * 
     * Get error message text
     * @deprecated This method has now been deprecated, use AxisException::what()
     * 
     * @return Exception message
     */
    const char* getMessage() const { return what(); }
    
    /**
      * The method setMessage(std::string psMessage) uses to set the private data member m_sMessage
      * This method should be used to set the m_sMessage variable in derived classes.
      * 
      * @param psMessage The exception message to be set.
      */
    void setMessage(const char* psMessage) { m_sMessage = psMessage ? psMessage : "";  }
     
    /**
      * The method setMessage(std::string psMessage) uses to set the code and message.
      * This method will retrieve the corresponding message for the exceptionCode and then append 
      * the detailMessage if set.
      * 
      * @param exceptionCode The exception code for which message is to be retrieved.
      * @param defaultMsg    If exception code cannot be mapped to message, this will be used.
      * @param detailMessage Additional message information that will be appended to the exception message.
      */
    void setMessage(int exceptionCode, const char *defaultMsg, const char* detailMessage=NULL)
    {
        m_iExceptionCode = exceptionCode;
        std::string sMessage = detailMessage ? detailMessage : "";
        m_sMessage = getMessageForExceptionCode(exceptionCode, defaultMsg) + "\n" + sMessage;
    }
    
    /** 
     * The method will set exception data from another exception
     * 
     * @param e Exception from which data is to be set.
     */
    void setExceptionFromException(const AxisException& e)
    {
        m_iExceptionCode = e.m_iExceptionCode;
        m_sMessage       = e.m_sMessage;
    }

    /**
      * The method will reset exception object as if no parameters
      * where passed to constructor
      */
    void resetException()
    {
        m_iExceptionCode = 0;
        m_sMessage       = "";
    }
    
    /**
     * This method is used to map AXIS exception code to a text message. Primarily used
     * by classes that inherit from AxisException. 
     * 
     * @param exceptionCode The exception code for which message is to be retrieved.
     * @param defaultMsg    If exception code cannot be mapped to message, this will be returned.
     */
     static std::string getMessageForExceptionCode(int exceptionCode, const char *defaultMsg=NULL)
     {
        std::string sMsg;
        
        switch (exceptionCode)
        {
            case SOAP_VERSION_MISMATCH:
                sMsg = "AxisSoapException: Soap VersionMismatch fault occurred.";
                break;
            case SOAP_MUST_UNDERSTAND:    
                sMsg = "AxisSoapException: Soap MustUnderstand fault occurred.";
                break;
            case CLIENT_SOAP_MESSAGE_INCOMPLETE:
                sMsg = "AxisSoapException: Soap message is incomplete.";
                break;
            case CLIENT_SOAP_SOAP_ACTION_EMTPY:
                sMsg = "AxisSoapException: SOAPAction HTTP header is empty.";
                break;
            case CLIENT_SOAP_SOAP_CONTENT_ERROR:
                sMsg = "AxisSoapException: Soap message content is not valid.";
                break;
            case CLIENT_SOAP_NO_SOAP_METHOD:
                sMsg = "AxisSoapException: Request method is not a soap method.";
                break;
            case CLIENT_SOAP_CONTENT_NOT_SOAP:
                sMsg = "AxisSoapException: Content is not a valid soap message.";
                break;
            case CLIENT_WSDD_SERVICE_NOT_FOUND:
                sMsg = "AxisWsddException: Requested service not found.";
                break;
            case CLIENT_WSDD_METHOD_NOT_ALLOWED:
                sMsg = "AxisWsddException: Requested method is not allowed.";
                break;
            case CLIENT_WSDD_PARA_TYPE_MISMATCH:
                sMsg = "AxisWsddException: Parameter type mismatch.";
                break;
            case CLIENT_ENGINE_CLIENT_HANDLER_FAILED:
                sMsg = "AxisEngineException: Client handler failed.";
                break;
            case CLIENT_TRANSPORT_EXCEPTION:
                sMsg = "HTTPTransportException: Client transport exception.";
                break;
            case CLIENT_TRANSPORT_OPEN_CONNECTION_FAILED:
                sMsg = "HTTPTransportException: Client failed to open.";
                break;
            case CLIENT_TRANSPORT_TYPE_MISMATCH:
                sMsg = "HTTPTransportException: Client attempted to use SSL functions without the proper prerequisites.";
                break;
            case CLIENT_TRANSPORT_HAS_NO_UNSECURE_TRANSPORT_LAYER:
                sMsg = "HTTPTransportException: Client attempted to use non-existant unsecure transport (http).";
                break;
            case CLIENT_TRANSPORT_HAS_NO_SECURE_TRANSPORT_LAYER:
                sMsg = "HTTPTransportException: Client attempted to use non-existant secure transport (https).";
                break;
            case CLIENT_MIME_CONTENT_ID_NOT_UNIQUE:
                sMsg = "AxisSoapException: Content is not unique within the MIME message.";
                break;
            case SERVER_ENGINE_EXCEPTION:
                sMsg = "AxisEngineException: Exception occurred.";
                break;
            case SERVER_ENGINE_COULD_NOT_LOAD_SRV:
                sMsg = "AxisEngineException: Could not load service.";
                break;
            case SERVER_ENGINE_COULD_NOT_LOAD_HDL:
                sMsg = "AxisEngineException: Could not load handler.";
                break;
            case SERVER_ENGINE_LOADING_TRANSPORT_FAILED:
                sMsg = "AxisEngineException: Failed to load transport library.";
                break;
            case SERVER_ENGINE_LOADING_PARSER_FAILED:
                sMsg = "AxisEngineException: Failed to load parser library.";
                break;
            case SERVER_ENGINE_HANDLER_FAILED:
                sMsg = "AxisEngineException: Handler failed.";
                break;
            case SERVER_ENGINE_WEBSERVICE_FAILED:
                sMsg = "AxisEngineException: Web service failed.";
                break;
            case SERVER_ENGINE_HANDLER_INIT_FAILED:
                sMsg = "AxisEngineException: Handler initialization failed.";
                break;
            case SERVER_ENGINE_HANDLER_CREATION_FAILED:
                sMsg = "AxisEngineException: Handler creation failed.";
                break;
            case SERVER_ENGINE_LIBRARY_LOADING_FAILED:
                sMsg = "AxisEngineException: Library loading failed.";
                break;
            case SERVER_ENGINE_HANDLER_NOT_LOADED:
                sMsg = "AxisEngineException: Handler is not loaded.";
                break;
            case SERVER_ENGINE_HANDLER_BEING_USED:
                sMsg = "AxisEngineException: Handler is being used.";
                break;
            case SERVER_ENGINE_GET_HANDLER_FAILED:
                sMsg = "AxisEngineException: Failed to get handler.";
                break;
            case SERVER_ENGINE_WRONG_HANDLER_TYPE:
                sMsg = "AxisEngineException: Wrong handler type.";
                break;
            case SERVER_CONFIG_EXCEPTION:
                sMsg = "AxisConfigException: Exception occurred.";
                break;
            case SERVER_CONFIG_TRANSPORT_CONF_FAILED:
                sMsg = "AxisConfigException: Transport layer is not configured properly.";
                break;
            case SERVER_CONFIG_LIBRARY_PATH_EMPTY:
                sMsg = "AxisConfigException: Library path is empty (not in server.wsdd file).";
                break;
            case SERVER_WSDD_FILE_NOT_FOUND:
                sMsg = "AxisWsddException: Unable to load file.";
                break;
            case SERVER_WSDD_EXCEPTION:
                sMsg = "AxisWsddException: Exception occurred.";
                break;
            case SERVER_WSDD_NO_HANDLERS_CONFIGURED:
                sMsg = "AxisWsddException: No handlers configured in server.wsdd file.";
                break;
            case SERVER_SOAP_EXCEPTION:
                sMsg = "AxisSoapException: Exception occurred.";
                break;
            case SERVER_TRANSPORT_EXCEPTION:
                sMsg = "HTTPTransportException: Exception occurred.";
                break;
            case CLIENT_SSLCHANNEL_RECEPTION_EXCEPTION:
            case SERVER_TRANSPORT_RECEPTION_EXCEPTION:
                sMsg = "HTTPTransportException: Problem occurred when receiving the stream.";
                break;
            case CLIENT_SSLCHANNEL_SENDING_EXCEPTION:
            case SERVER_TRANSPORT_SENDING_EXCEPTION:
                sMsg = "HTTPTransportException: Problem occurred when sending the stream.";
                break;
            case SERVER_TRANSPORT_PROCESS_EXCEPTION:
                sMsg = "HTTPTransportException: Cannot process response message.";
                break;
            case SERVER_TRANSPORT_UNKNOWN_HTTP_RESPONSE:
                sMsg = "HTTPTransportException: Unknown HTTP response, cannot process response message.";
                break;
            case CLIENT_SSLCHANNEL_CONTEXT_CREATE_ERROR:
                sMsg = "HTTPTransportException: Context creation error.";
                break;
            case CLIENT_SSLCHANNEL_ERROR:
                sMsg = "HTTPTransportException: HTTPS transport error.";
                break;
            case SERVER_TRANSPORT_HTTP_EXCEPTION:
                sMsg = "HTTPTransportException: HTTP transport error.";
                break;
            case SERVER_TRANSPORT_UNEXPECTED_STRING:
                sMsg = "HTTPTransportException: Unexpected string received.";
                break;
            case CLIENT_SSLCHANNEL_CHANNEL_INIT_ERROR:    
            case SERVER_TRANSPORT_CHANNEL_INIT_ERROR:
                sMsg = "HTTPTransportException: Cannot initialize a channel to the remote end.";
                break;
            case CLIENT_SSLCHANNEL_SOCKET_CREATE_ERROR:                
            case SERVER_TRANSPORT_SOCKET_CREATE_ERROR:
                sMsg = "AxisTransportException: Unable to create a socket.";
                break;
            case CLIENT_SSLCHANNEL_SOCKET_CONNECT_ERROR:                
            case SERVER_TRANSPORT_SOCKET_CONNECT_ERROR:
                sMsg = "AxisTransportException: Cannot open a channel to the remote end.";
                break;
            case CLIENT_SSLCHANNEL_INVALID_SOCKET_ERROR:                
            case SERVER_TRANSPORT_INVALID_SOCKET:
                sMsg = "AxisTransportException: Socket not valid.";
                break;
            case SERVER_TRANSPORT_OUTPUT_STREAMING_ERROR:
                sMsg = "HTTPTransportException: Output streaming error while writing to channel.";
                break;
            case SERVER_TRANSPORT_INPUT_STREAMING_ERROR:
                sMsg = "HTTPTransportException: Input streaming error while reading from channel.";
                break;
            case SERVER_TRANSPORT_TIMEOUT_EXCEPTION:
                sMsg = "HTTPTransportException: Channel error while doing a timed wait.";
                break;
            case SERVER_TRANSPORT_TIMEOUT_EXPIRED:
                sMsg = "HTTPTransportException: Channel I/O operation timed out.";
                break;
            case SERVER_TRANSPORT_LOADING_SSLCHANNEL_FAILED:
            case SERVER_TRANSPORT_LOADING_CHANNEL_FAILED:
                sMsg = "HTTPTransportException: Unable to load channel library.";
                break;
            case SERVER_TRANSPORT_BUFFER_EMPTY:
                sMsg = "HTTPTransportException: Transport buffer is empty.";
                break;
            case SERVER_PARSE_BUFFER_EMPTY:
                sMsg = "AxisParseException: Buffer received from the parser is empty.";
                break;
            case SERVER_PARSE_PARSER_FAILED: 
                sMsg = "AxisParseException: Parser error occurred.";
                break;
            case SERVER_PARSE_TRANSPORT_FAILED:
                sMsg = "AxisParseException: Error when getting the byte stream from the transport.";
                break;
            case SERVER_TEST_EXCEPTION:
                sMsg = "This is a testing error.";
                break;
            case SERVER_CLIENT_ENGINE_MISMATCH:
                sMsg = "AxisEngineException: Engine cannot be initialized as both client and server.";
                break;
            case AXISC_SERVICE_THROWN_EXCEPTION:
                sMsg = "A service has thrown an exception.";
                break;
            case AXISC_UNKNOWN_ELEMENT_EXCEPTION:
                sMsg = "AxisParseException: Unknown element encountered.";
                break;
            case AXISC_NODE_VALUE_MISMATCH_EXCEPTION:
                sMsg = "AxisSoapException: Cannot deserialize the requested element.";
                break;
            case AXISC_READ_CONF_EXCEPTION:
                sMsg = "AxisConfigException: Unable to read configuration file.";
                break;
            case CONFIG_DEFAULTS_ALREADY_SET:  
                sMsg = "AxisConfigException: Configuration defaults have already been set.";
                break;
            case SERVER_UNKNOWN_ERROR:
            default:    
                sMsg= defaultMsg ? defaultMsg : "AxisException:";      
                break;
        }
        
        return sMsg;
     }

protected:
    /**
      * This data member is common to all the inherited classes of this base class.
      * The integer variable m_iExceptionCode stores the Exception code
      */
    int m_iExceptionCode;

    /**
      * This data member is common to all the inherited classes of this base class.
      * The variable m_sMessage is used to store the Exception message
      */
    std::string m_sMessage;
};

AXIS_CPP_NAMESPACE_END

#endif