/*
 *   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 BasicHandler.hpp
 *
 * @author Susantha Kumara (skumara@virtusa.com)
 * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com) *
 */
  
#if !defined(_BASICHANDLER_H__OF_AXIS_INCLUDED_)
#define _BASICHANDLER_H__OF_AXIS_INCLUDED_

#include <axis/IMessageData.hpp>
#include <axis/GDefine.hpp>

AXIS_CPP_NAMESPACE_START

/**
 * @enum HANDLER_TYPE
 * Enumeration to indicate the type of handler
 */
typedef enum {
    /**
     * Handler
     */
    NORMAL_HANDLER,
    
    /**
     * Web Service
     */
    WEBSERVICE_HANDLER,
    
    /**
     * Handler Chain, a chain contains 1 or more Handlers
     */
    CHAIN_HANDLER
} HANDLER_TYPE;

/**
 * @struct BasicHandlerFunctions
 * 
 * Structure containing function pointers to the BasicHandler functions
 */
typedef struct 
{
    /**
     * Function pointer to the BasicHandler invoke method
     */
    int (AXISCALL* invoke)(void* _object, void*);
    
    /**
     * Function pointer to the BasicHandler onFault method
     */
    void (AXISCALL* onFault)(void* _object, void*);
    
    /**
     * Function pointer to the BasicHandler init method
     */
    int (AXISCALL* init)(void* _object);
    
    /**
     * Function pointer to the BasicHandler fini method
     */
    int (AXISCALL* fini)(void* _object);
    
    /**
     * Function pointer to the BasicHandler getType method
     */
    int (AXISCALL* getType)(void* _object);
    
    /**
     * Function pointer to the BasicHandler getBindingStyle method
     */
    AXIS_BINDING_STYLE (AXISCALL* getBindingStyle)(void* _object);
} BasicHandlerFunctions;

/**
 * @struct BasicHandler
 * 
 * Structure containing handler instance and functions
 */
typedef struct 
{
    /**
     * Handler instance.
     * 
     * For C++ implementations this will be an instance of HandlerBase.
     */
    void* _object; 
    /**
     * Structure of function pointers.
     * 
     * Present only for interfaces passed from C to C++ (eg:BasicHandler)
     */
    BasicHandlerFunctions* _functions;
} BasicHandler;

/**
  * @class HandlerBase
  * @brief interface for the Handlers. This is the base class for:
  *        - Handler 
  *        - WrapperClassHandler
  * In the Axis Architecture there are different types of Handlers :
  *        - NORMAL_HANDLER : A Handler which is used to process SOAP Headers.
  *        - WEBSERVICE_HANDLER : A web service is also considered as a Handler.
  *        - CHAIN_HANDLER : Handler Chains are also derived from Handler.
  * Each of these handlers will inherit from this HandlerBase which serves as
  * the base point for all the different types of Handlers.
  *
  * @author Susantha Kumara (skumara@virtusa.com)
  * @author Roshan Weerasuriya (roshan@opensource.lk, roshanw@jkcsworld.com)
  *
  */

/*
 * Revision 1.1  2004/06/14 roshan
 * Added doxygen comments to help autobuild API docs
 */

class HandlerBase
{
public:
    /**
      * Constructor.
      */
    HandlerBase(){};

    /**
      * Destructor.
      */
    virtual ~HandlerBase(){};

    /**
      * The invoke method is automatically called by the Axis Engine when it
      * needs to execute a Handler. The main task of the handler which a
      * Handler writer expects the Handler to be performed needs to be written
      * within the invoke method of the Handler.
      *
      * A example code segment within a invoke method which is written to
      * process a SOAP Header is as following:
      * <PRE>
      * int ESHHandler::invoke(void *pvIMsg)
      * {
      * IMessageData *pIMsg = (IMessageData*) pvIMsg;
      *    AxisChar* pachTemp;
      *    if(pIMsg->isPastPivot()) {
      *        //this is a response
      *
      *        IHandlerSoapSerializer* pISZ;
      *        pIMsg->getSoapSerializer(&pISZ);
      *
      *        IHeaderBlock* pIHeaderBlock= pISZ->createHeaderBlock();
      *
      *        pIHeaderBlock->setLocalName("echoMeStringResponse");
      *        pIHeaderBlock->setURI("http://soapinterop.org/echoheader/");
      *
      *        pachTemp = "EchoStringHeaderHandlerPr1.id";
      *
      *        const AxisChar* pachHeaderVal = pIMsg->getProperty(pachTemp);
      *        printf("in the ESHHandler::Invoke : %s\n",pachHeaderVal);
      *
      *        BasicNode* pBasicNode = pIHeaderBlock->createChild(CHARACTER_NODE);
      *        pBasicNode->setValue(pachHeaderVal);
      *
      *        pIHeaderBlock->addChild(pBasicNode);
      *
      * } else {
      *        //this is a request
      *
      *        IHandlerSoapDeSerializer* pIHandlerSoapDeSerializer;
      *        pIMsg->getSoapDeSerializer(&pIHandlerSoapDeSerializer);
      *
      *        IHeaderBlock* pIHeaderBlock= pIHandlerSoapDeSerializer->getHeaderBlock("echoMeString", "http://soapinterop.org/echoheader/");
      *
      *        if (pIHeaderBlock != NULL) {
      *
      *            const BasicNode* pBasicNode= pIHeaderBlock->getFirstChild();
      *
      *            const AxisChar* pachHeaderValue;
      *
      *            if (pBasicNode != NULL)
      *            {
      *                if((pBasicNode->getNodeType()) == CHARACTER_NODE) {
      *                    pachHeaderValue= pBasicNode->getValue();
      *                } else {
      *                    pachHeaderValue = "This was not the expected value Ros";
      *                }
      *            } else
      *            {
      *                pachHeaderValue = "pBascNode is NULL";
      *            }
      *
      *            AxisChar* pachTmpValue = (AxisChar*) malloc(strlen(pachHeaderValue) + 4);
      *            strcpy(pachTmpValue, pachHeaderValue);
      *
      *            pachTemp = "EchoStringHeaderHandlerPr1.id";
      *            pIMsg->setProperty(pachTemp, pachTmpValue);
      *
      *            free(pachTmpValue);
      *
      *
      *        } else {
      *            //do some thing
      *        }
      *
      *    }
      *
      *    return AXIS_SUCCESS;
      *    }
      * </PRE>
      *
      * In case of a Web Service Handler the invoke method should do what is
      * required by a web service invoke method, which is different from the
      * above shown example.
      *
      * @param pMsg The MessageData object pointer. This MessageData object is
      * passed to every handler when serving to a client request. The handler
      * writer can get access to objects such as:
      *        - IHandlerSoapDeSerializer
      *        - IHandlerSoapSerializer
      *        - The properties/data/info which are set by other handlers
      *        - The properties/data/info which is set by the Client Stub in case
      *          the Handler is a Client side Handler.
      *                                                etc.
      * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
      */
    virtual int AXISCALL invoke(void* pMsg)=0;

    /**
      * Called when ever a fault is occured within the handler. The tasks which
      * needs to be persormed when ever an error occurs within a Handler has
      * to be written within this method.
      *
      * @param mMsg The MessageData object pointer. This MessageData object is
      * passed to every handler when serving to a client request. The handler
      * writer can get access to objects such as:
      *        - IHandlerSoapDeSerializer
      *        - IHandlerSoapSerializer
      *                                etc.
      * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
      */
    virtual void AXISCALL onFault(void* mMsg)=0;

    /**
      * The initialization tasks which needs to be performed within a Handler
      * has to be written here. This method will be automatically called by the
      * Axis Engine when it loads a handler.
      *
      * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
      */
    virtual int AXISCALL init()=0;

    /**
      * The finalization tasks which needs to be performed within a Handler
      * has to be written here. This method will be automatically called by the
      * Axis Engine when it unloads a handler.
      *
      * @return AXIS_SUCCESS or AXIS_FAIL to indicate success or fail.
      */
    virtual int AXISCALL fini()=0;

    /**
      * Gets and returns the type of the handler. The return value could be :
      *        - NORMAL_HANDLER
      *        - WEBSERVICE_HANDLER
      *        - CHAIN_HANDLER
      *
      *    @return This returns the following depending on the actual Handler
      * type:
      *        - NORMAL_HANDLER : In case of a normal Handler which is used to
      *                           process SOAP Headers.
      *        - WEBSERVICE_HANDLER : In case of a Web Service.
      *        - CHAIN_HANDLER : In case of a HandlerChain
      */
    virtual int AXISCALL getType()=0;
};

AXIS_CPP_NAMESPACE_END

#endif