it_bus_pdk/messaging_server_operation.h

#ifndef _IT_BUS_PDK_MESSAGING_OP_HANDLER_H_
#define _IT_BUS_PDK_MESSAGING_OP_HANDLER_H_

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

#include <it_bus/api_defines.h>
#include <it_bus/message_writer.h>
#include <it_bus/message_reader.h>
#include <it_bus/operation.h>
#include <it_bus_pdk/transport_readable_message.h>
#include <it_bus_pdk/transport_writable_message.h>
#include <it_bus_pdk/messaging_port.h>
#include <it_bus_pdk/pass_thru_operation.h>

namespace IT_Bus
{
    class BusContextRegistry;
    class Endpoint;
    class SendMessageContext;
    class DispatchInfo;

    class IT_BUS_API MessagingServerOperation : public ServerOperation, public ServerOperationPassThrough
    {
      public:
        MessagingServerOperation(
            MessageReader & message_reader,
            MessageWriter*  message_writer,
            const IT_WSDL::WSDLPort & wsdl_port,
            const IT_WSDL::WSDLOperation& wsdl_operation,
            MessagingPort & messaging_port,
            BusContextRegistry& context_registry,
            ContextContainer* request_contexts,
            ContextContainer* reply_contexts
        );

        virtual 
        ~MessagingServerOperation();

        virtual ReadableMessage & 
        get_input_message();
        
        virtual WritableMessage & 
        get_output_message();

        virtual TransportReadableMessage & 
        get_transport_input_message();
        
        virtual TransportWritableMessage & 
        get_transport_output_message();

        virtual ContextContainer*
        request_contexts();

        virtual ContextContainer*
        reply_contexts();

        virtual void
        read();

        virtual void
        write();

        void
        exception_occured();

        virtual MessageReader*
        get_message_reader();

        virtual MessageWriter*
        get_message_writer();

        void
        set_contexts(
            ContextContainer* request_contexts,
            ContextContainer* reply_contexts
        );

        virtual ServerOperationPassThrough*
        get_server_pass_through();

        // The following 3 methods are implementing the ServerOperationPassThrough API
        BinaryBuffer*
        get_passthru_reply();

        BinaryBuffer*
        get_passthru_request();

        void
        enable_passthru();

        // The following 3 methods are needed by the MessagingPort itself for
        // support of passthru
        void
        set_passthru_reply(
            BinaryBuffer* buffer
        );

        void
        set_passthru_request(
            BinaryBuffer* buffer
        );

        bool
        passthru_enabled();

        void
        set_message_writer(
            MessageWriter*
        );

        void
        set_send_message_context(
            SendMessageContext* message_context
        );

        SendMessageContext*
        get_send_message_context();

        void
        set_dispatch_context(
            DispatchInfo* dispatch_context
        );

        DispatchInfo*
        get_dispatch_context();

        CorrelationId
        get_correlation_id() const;

        void
        notify_async_dispatch();

        void
        set_reply_contexts(
            ContextContainer* container
        );

      private:
        MessagingServerOperation & 
        operator = (
            const MessagingServerOperation& rhs
        );

        MessagingServerOperation(
            const MessagingServerOperation& rhs
        );

        void
        take_contexts();
        

        MessageWriter*           m_message_writer;
        MessageReader&           m_message_reader;
        TransportWritableMessage m_output_message;
        TransportReadableMessage m_input_message;

        MessagingPort&      m_messaging_port;
        BusContextRegistry& m_context_registry;
        ContextContainer*   m_request_contexts;
        ContextContainer*   m_reply_contexts;
        BinaryBuffer*       m_passthru_request_buffer;
        BinaryBuffer*       m_passthru_reply_buffer;
        bool                m_passthru_enabled;
        bool                m_contexts_in_tls;
        SendMessageContext* m_message_context;
        DispatchInfo*       m_dispatch_context;
        bool                m_async_dispatch;
    };

    inline void
    MessagingServerOperation::set_reply_contexts(
        ContextContainer* container
    )
    {
        assert(m_async_dispatch);
        assert(m_reply_contexts == 0);
        m_reply_contexts = container;
    }
}

#endif  

---