template class Poco::Net::SocketAcceptor

Overview

This class implements the Acceptor part of the Acceptor-Connector design pattern. More…

#include <SocketAcceptor.h>

template <class ServiceHandler>
class SocketAcceptor
{
public:
    // construction

    SocketAcceptor(ServerSocket& socket);

    SocketAcceptor(
        ServerSocket& socket,
        SocketReactor& reactor
        );

    // methods

    void
    setReactor(SocketReactor& reactor);

    virtual
    void
    registerAcceptor(SocketReactor& reactor);

    virtual
    void
    unregisterAcceptor();

    void
    onAccept(ReadableNotification* pNotification);

protected:
    // methods

    virtual
    ServiceHandler*
    createServiceHandler(StreamSocket& socket);

    SocketReactor*
    reactor();

    Socket&
    socket();
};

Detailed Documentation

This class implements the Acceptor part of the Acceptor-Connector design pattern.

The Acceptor-Connector pattern has been described in the book “Pattern Languages of Program Design 3”, edited by Robert Martin, Frank Buschmann and Dirk Riehle (Addison Wesley, 1997).

The Acceptor-Connector design pattern decouples connection establishment and service initialization in a distributed system from the processing performed once a service is initialized. This decoupling is achieved with three components: Acceptors, Connectors and Service Handlers. The SocketAcceptor passively waits for connection requests (usually from a remote Connector) and establishes a connection upon arrival of a connection requests. Also, a Service Handler is initialized to process the data arriving via the connection in an application-specific way.

The SocketAcceptor sets up a ServerSocket and registers itself for a ReadableNotification, denoting an incoming connection request.

When the ServerSocket becomes readable the SocketAcceptor accepts the connection request and creates a ServiceHandler to service the connection.

The ServiceHandler class must provide a constructor that takes a StreamSocket and a SocketReactor as arguments, e.g.:

MyServiceHandler(const StreamSocket& socket, ServiceReactor& reactor)

When the ServiceHandler is done, it must destroy itself.

Subclasses can override the createServiceHandler() factory method if special steps are necessary to create a ServiceHandler object.

Construction

SocketAcceptor(
    ServerSocket& socket,
    SocketReactor& reactor
    )

Creates a SocketAcceptor, using the given ServerSocket.

The SocketAcceptor registers itself with the given SocketReactor.

Methods

void
setReactor(SocketReactor& reactor)

Sets the reactor for this acceptor.

virtual
void
registerAcceptor(SocketReactor& reactor)

Registers the SocketAcceptor with a SocketReactor.

A subclass can override this function to e.g. register an event handler for timeout event.

If acceptor was constructed without providing reactor to it, the override of this method must either call the base class implementation or directly register the accept handler with the reactor.

virtual
void
unregisterAcceptor()

Unregisters the SocketAcceptor.

A subclass can override this function to e.g. unregister its event handler for a timeout event.

If the accept handler was registered with the reactor, the overriding method must either call the base class implementation or directly unregister the accept handler.

void
onAccept(ReadableNotification* pNotification)

Accepts connection and creates event handler.

virtual
ServiceHandler*
createServiceHandler(StreamSocket& socket)

Create and initialize a new ServiceHandler instance.

Subclasses can override this method.

SocketReactor*
reactor()

Returns a pointer to the SocketReactor where this SocketAcceptor is registered.

The pointer may be null.

Socket&
socket()

Returns a reference to the SocketAcceptor ‘s socket.