it_bus_pdk/interceptor.h

#ifndef _IT_BUS_PDK_INTERCEPTOR_H_
#define _IT_BUS_PDK_INTERCEPTOR_H_

// @Copyright 2004 IONA Technologies, Plc. All Rights Reserved.
//

#include <it_bus/api_defines.h>
#include <it_wsdl/wsdl_definitions.h>
#include <it_dsa/vector.h>

namespace IT_Bus
{
    class Operation;
    class ClientOperation;
    class ServerOperation;

    class Interceptor;
    class InterceptorFactory;
    class ServerMessageInterceptorNode;
    class ServerRequestInterceptorNode;
    class ClientMessageInterceptor;
    class ClientRequestInterceptor;

    class ContextContainer;
    class DispatchInfo;

    typedef IT_Vector<ServerMessageInterceptorNode*> ServerMessageInterceptorChain;
    typedef IT_Vector<ServerRequestInterceptorNode*> ServerRequestInterceptorChain;
    typedef IT_Vector<ClientMessageInterceptor*> ClientMessageInterceptorChain;
    typedef IT_Vector<ClientRequestInterceptor*> ClientRequestInterceptorChain;

    enum InterceptorType
    {
        CPP_INTERCEPTOR,
        JAVA_INTERCEPTOR
    };

    class IT_BUS_API Interceptor
    {
      public:
        Interceptor();

        Interceptor(
            InterceptorFactory* factory
        );
        
        virtual ~Interceptor();

        virtual InterceptorFactory*
        get_factory();

        virtual InterceptorType
        get_type();
     
      private:      

        InterceptorFactory* m_factory;
    };

    class IT_BUS_API ServerMessageInterceptor : public virtual Interceptor
    {
      public:
        ServerMessageInterceptor();

        ServerMessageInterceptor(
            InterceptorFactory* factory
        );
        
        virtual ~ServerMessageInterceptor();
        
        virtual void
        chain_assembled(
            ServerMessageInterceptorChain& chain
        );

        virtual void
        chain_finalized(
            ServerMessageInterceptor* next_interceptor
        );

        virtual void
        message_received(
            BinaryBuffer& in_message,
            DispatchInfo& dispatch_context
        );
        
        virtual void
        send_message(
            BinaryBuffer& out_message,
            DispatchInfo& dispatch_context
        );

      protected:

        ServerMessageInterceptor* m_in_interceptor;

        ServerMessageInterceptor* m_out_interceptor;
    };

    class IT_BUS_API ServerRequestInterceptor : public virtual Interceptor
    {
      public:
        ServerRequestInterceptor();

        ServerRequestInterceptor(
            InterceptorFactory* factory
        );
        
        virtual ~ServerRequestInterceptor();

        virtual void
        chain_assembled(
            ServerRequestInterceptorChain& chain
        );

        virtual void
        chain_finalized(
            ServerRequestInterceptor* next_interceptor
        );

        virtual void
        intercept_pre_dispatch(
            ServerOperation& data
        );

        virtual void
        intercept_post_dispatch(
            ServerOperation& data
        );

        virtual void
        intercept_around_dispatch(
            ServerOperation& data
        );

      protected:
        ServerRequestInterceptor* m_next_interceptor;

        ServerRequestInterceptor* m_prev_interceptor;
    };

    class IT_BUS_API ClientMessageInterceptor : public virtual Interceptor
    {
      public:
        ClientMessageInterceptor();

        ClientMessageInterceptor(
            InterceptorFactory* factory
        );
        
        virtual ~ClientMessageInterceptor();

        virtual void
        chain_assembled(
            ClientMessageInterceptorChain& chain
        );

        virtual void
        chain_finalized(
            ClientMessageInterceptor* next_interceptor
        );

        virtual void
        intercept_invoke(
            const IT_WSDL::WSDLOperation& wsdl_op,
            BinaryBuffer&                 request_buffer,
            BinaryBuffer&                 response_buffer,
                        ContextContainer*             out_container,
                        ContextContainer*             in_container
        );

      protected:
        ClientMessageInterceptor* m_next_interceptor;
    };

    class IT_BUS_API ClientRequestInterceptor : public virtual Interceptor
    {
      public:
        ClientRequestInterceptor();

        ClientRequestInterceptor(
            InterceptorFactory* factory
        );
        
        virtual ~ClientRequestInterceptor();

        virtual void
        chain_assembled(
            ClientRequestInterceptorChain& chain
        );

        virtual void
        chain_finalized(
            ClientRequestInterceptor* next_interceptor
        );

        virtual void
        intercept_invoke(
            ClientOperation& data
        );

      protected:
        ClientRequestInterceptor* m_next_interceptor;
    };

    class IT_BUS_API InterceptorFactory
    {
      public:

        virtual ClientMessageInterceptor *
        get_client_message_interceptor(
            const IT_WSDL::WSDLNode* const wsdl_node = 0
        );

        virtual void
        destroy_client_message_interceptor(
            ClientMessageInterceptor * message_interceptor
        );

        virtual ClientRequestInterceptor *
        get_client_request_interceptor(
            const IT_WSDL::WSDLNode* const wsdl_node = 0
        );

        virtual void
        destroy_client_request_interceptor(
            ClientRequestInterceptor * request_interceptor
        );

        virtual ServerMessageInterceptor*
        get_server_message_interceptor(
            const IT_WSDL::WSDLNode* const wsdl_node = 0
        );

        virtual void
        destroy_server_message_interceptor(
            ServerMessageInterceptor* message_interceptor
        );

        virtual ServerRequestInterceptor*
        get_server_request_interceptor(
            const IT_WSDL::WSDLNode* const wsdl_node = 0
        );

        virtual void
        destroy_server_request_interceptor(
            ServerRequestInterceptor* request_interceptor
        );

        virtual const String
        name() = 0;

        virtual const String&
        description() const;

      protected:
        InterceptorFactory();

        virtual 
        ~InterceptorFactory();

        InterceptorFactory & 
        operator = (
            const InterceptorFactory& rhs
        );

        InterceptorFactory(
            const InterceptorFactory& rhs
        );
    };

    typedef IT_Vector<InterceptorFactory*> InterceptorFactoryList;
}

#endif  

---