it_bus_pdk/endpoint.h

#ifndef _IT_BUS_PDK_ENDPOINT_H_
#define _IT_BUS_PDK_ENDPOINT_H_

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

#include <it_bus/api_defines.h>

namespace IT_WSDL
{
    class WSDLPort;
    class WSDLOperation;
    class WSDLExtensionElement;
}

namespace WS_Addressing_2004
{
    class AttributedURI;
}

namespace IT_Bus
{
    class String;
    class Port;
    class SendMessageContext;
    class ReceiveMessageContext;
    class AnyType;
    class SoftStopEndpoint;
    class TransactionalEndpoint;
    class TransportReadableMessage;
    class TransportWritableMessage;
    class MessageReader;
    class MessageWriter;
    class ContextContainer;
    class DispatchInfo;

    /*
     * The following interface is the base
     * class for implementing Endpoint.
     * It is also used for implementing
     * an asynchronous endpoint.
     */
    class IT_BUS_API Endpoint
    {
      public:

        virtual const WS_Addressing_2004::AttributedURI&
        get_address() = 0;

        virtual const IT_WSDL::WSDLExtensionElement&
        get_configuration() = 0;

        /*
         * Sends a message described in the SendMessageContext
         * on the endpoint. Optionally returns an AnyType*
         * that can hold a message-id understood by the
         * caller to correlate with a response received
         * via EndpointHandler::message_received()
         */
        virtual AnyType*
        send_message(
            SendMessageContext*
        ) = 0;

        /*
         * close the endpoint
         */
        virtual void
        close() = 0;

        /*
         * Returns the underlying softstop endpoint.
         * If the endpoint implements a SoftStopEndpoint,
         * it could decide to return pointer to itself.
         * Alternately, it could simply call the underlying
         * endpoint's Endpoint::get_underlying_softstop_endpoint()
         * to get an underlying SoftStopEndpoint.
         */
        virtual SoftStopEndpoint*
        get_underlying_softstop_endpoint() = 0;

        /*
         * Returns the underlying transactional endpoint.
         * If the endpoint implements a TransactionalEndpoint,
         * it could decide to return pointer to itself.
         * Alternately, it could simply call the underlying
         * endpoint's Endpoint::get_underlying_transactional_endpoint()
         * to get an underlying SoftStopEndpoint.
         */
        virtual TransactionalEndpoint*
        get_underlying_transactional_endpoint() = 0;

        Endpoint() {}
        virtual ~Endpoint();
    };

    /*
     * The following interface acts as an Observer
     * for an asynchronous Endpoint.
     */
    class IT_BUS_API EndpointHandler
    {
      public:

       /*
        * Notification that the underlying
        * endpoint is created.
        */
        virtual void
        endpoint_created(
            Endpoint*
        ) = 0;

       /*
        * When a message is received on the
        * underlying asynchronous Endpoint,
        * it's delivered via call to
        * message_received().
        */
        virtual void
        message_received(
            AnyType*,
            ReceiveMessageContext*
        ) = 0;

       /*
        * Notification that the remote
        * endpoint is closed.
        */
        virtual void
        remote_endpoint_closed(
            const WS_Addressing_2004::AttributedURI& remote_endpoint_uri
        ) = 0;

       /*
        * Notification that the underlying
        * endpoint is closed.
        */
        virtual void
        endpoint_closed() = 0;

      protected:

        EndpointHandler() {}
        virtual ~EndpointHandler();
    };

    /*
     * The following interface is used to implement
     * a synchronous endpoint.
     */
    class IT_BUS_API SyncEndpoint
        : public Endpoint
    {
      public:

        /*
         * Synchronously sends a request message and
         * receives a reply message. Used to implement
         * synchronous client endpoints.
         */
        virtual void
        invoke(
            SendMessageContext*,
            ReceiveMessageContext&
        ) = 0;

      protected:

        SyncEndpoint() {}
        virtual ~SyncEndpoint();
    };

    /*
     * The following interface is used to implement
     * a SoftStop endpoint.
     */
    class IT_BUS_API SoftStopEndpoint
        : public Endpoint
    {
      public:

        /*
         * Deactivates the endpoint. The caller
         * could then either call reactivate() to
         * reactivate the endpoint, or call close()
         * to close the endpoint
         */
        virtual void
        deactivate() = 0;

        /*
         * Reactivates the deactivated endpoint.
         */
        virtual void
        reactivate() = 0;

        virtual void
        get_reference_with_id(
            const IT_Bus::String& instance_id,
            IT_WSDL::WSDLPort&    wsdl_port
        ) = 0;

      protected:

        SoftStopEndpoint() {}
        virtual ~SoftStopEndpoint();
    };

    /*
     * The following interface is used to implement
     * a Transactional endpoint.
     */
    class IT_BUS_API TransactionalEndpoint
        : public Endpoint
    {
      public:

        virtual bool
        supports_transactions() = 0;

        virtual void
        begin() = 0;

        virtual void
        commit() = 0;

        virtual void
        rollback() = 0;

      protected:

        TransactionalEndpoint() {}
        virtual ~TransactionalEndpoint();
    };

    /*
     * The following interface is used as a factory
     * to create synchronous endpoints and asynchronous
     * endpoints. The caller passes his implementation
     * of an EndpointHandler while requesting for creating
     * a Synchronous Endpoint. An Endpoint is created
     * either from a WS-Addressing EPR or a WSDLPort.
     */
    class IT_BUS_API EndpointManager
    {
      public:

        virtual SyncEndpoint*
        create_sync_endpoint(
            const IT_WSDL::WSDLPort& wsdl_port,
            ContextContainer*        context_container
        ) = 0;

        virtual SyncEndpoint*
        create_sync_endpoint(
            const IT_WSDL::WSDLPort&                 wsdl_port,
            const WS_Addressing_2004::AttributedURI& to_address,
            ContextContainer*                        context_container
        ) = 0;

        virtual Endpoint*
        create_async_endpoint(
            const IT_WSDL::WSDLPort& wsdl_port,
            EndpointHandler*         endpoint_handler,
            ContextContainer*        context_container
        ) = 0;

        virtual Endpoint*
        create_async_endpoint(
            const IT_WSDL::WSDLPort&                 wsdl_port,
            const WS_Addressing_2004::AttributedURI& listento_address,
            EndpointHandler*                         endpoint_handler,
            ContextContainer*                        context_container
        ) = 0;

        virtual SendMessageContext*
        create_send_message_context(
            IT_WSDL::WSDLOperation*,
            TransportWritableMessage*,
            MessageWriter*,
            ContextContainer*,
            DispatchInfo*,
            bool is_request,
            bool passthru_enabled
        ) = 0;

        virtual ReceiveMessageContext*
        create_receive_message_context(
            MessageReader*,
            ContextContainer*,
            DispatchInfo*
        ) = 0;

        virtual void
        close() = 0;

        virtual bool
        transport_acknowledgement_required(
            ContextContainer*
        ) = 0;

      protected:

        EndpointManager() {}
        virtual ~EndpointManager();
    };

    class IT_BUS_API EndpointManagerFactory
    {
      public:

        virtual const IT_Bus::String&
        get_name() = 0;

        virtual EndpointManager*
        create_endpoint_manager(
            IT_Bus::Port&
        ) = 0;

      protected:

        EndpointManagerFactory() {}
        virtual ~EndpointManagerFactory();
    };
}

#endif  

---