# Poco::Net

# template < class ServiceHandler >

# class SocketAcceptor

Library: Net
Package: Reactor
Header: Poco/Net/SocketAcceptor.h

## Description

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.

## Member Summary

Member Functions: createServiceHandler, onAccept, operator =, reactor, registerAcceptor, setReactor, socket, unregisterAcceptor

## Types Aliases

### Observer

using Observer = Poco::NObserver < SocketAcceptor, ReadableNotification >;

## Constructors

### SocketAcceptor

SocketAcceptor() = delete;

### SocketAcceptor

explicit SocketAcceptor(
ServerSocket & socket
);

Creates a SocketAcceptor, using the given ServerSocket.

### SocketAcceptor

SocketAcceptor(
const SocketAcceptor & param484
) = delete;

### SocketAcceptor

SocketAcceptor(
ServerSocket & socket,
SocketReactor & reactor
);

Creates a SocketAcceptor, using the given ServerSocket. The SocketAcceptor registers itself with the given SocketReactor.

## Destructor

### ~SocketAcceptor

virtual ~SocketAcceptor();

Destroys the SocketAcceptor.

## Member Functions

### onAccept

void onAccept(
const AutoPtr < ReadableNotification > & pNotification
);

Accepts connection and creates event handler.

### operator =

SocketAcceptor & operator = (
const SocketAcceptor & param485
) = delete;

### registerAcceptor

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.

### setReactor

void setReactor(
SocketReactor & reactor
);

Sets the reactor for this acceptor.

### unregisterAcceptor

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.

### createServiceHandler

virtual ServiceHandler * createServiceHandler(
StreamSocket & socket
);

Create and initialize a new ServiceHandler instance.

Subclasses can override this method.

### reactor

SocketReactor * reactor();

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

The pointer may be null.

### socket

Socket & socket();

Returns a reference to the SocketAcceptor's socket.