# ACE_Strategy_Acceptor< SVC_HANDLER, > Class Template Reference

Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER. More...

`#include <Acceptor.h>`

Inheritance diagram for ACE_Strategy_Acceptor< SVC_HANDLER, >:

[legend]
Collaboration diagram for ACE_Strategy_Acceptor< SVC_HANDLER, >:

[legend]
List of all members.

## Public Types

typedef ACE_Creation_Strategy< SVC_HANDLER > | creation_strategy_type
typedef ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > | accept_strategy_type
typedef ACE_Concurrency_Strategy< SVC_HANDLER > | concurrency_strategy_type
typedef ACE_Scheduling_Strategy< SVC_HANDLER > | scheduling_strategy_type
typedef ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > | base_type
typedef ACE_Creation_Strategy< SVC_HANDLER > | CREATION_STRATEGY
typedef ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > | ACCEPT_STRATEGY
typedef ACE_Concurrency_Strategy< SVC_HANDLER > | CONCURRENCY_STRATEGY
typedef ACE_Scheduling_Strategy< SVC_HANDLER > | SCHEDULING_STRATEGY

## Public Member Functions

| ACE_Strategy_Acceptor (const ACE_TCHAR service_name[]=0, const ACE_TCHAR service_description[]=0, int use_select=1, int reuse_addr=1)
| Default constructor.

ACE_Strategy_Acceptor (const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor *=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > *=0, ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > *=0, ACE_Concurrency_Strategy< SVC_HANDLER > *=0, ACE_Scheduling_Strategy< SVC_HANDLER > *=0, const ACE_TCHAR service_name[]=0, const ACE_TCHAR service_description[]=0, int use_select=1, int reuse_addr=1)

virtual int | open (const ACE_PEER_ACCEPTOR_ADDR &local_addr, ACE_Reactor *reactor, int flags=0, int use_select=1, int reuse_addr=1)
virtual int | open (const ACE_PEER_ACCEPTOR_ADDR &, ACE_Reactor *=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > *=0, ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > *=0, ACE_Concurrency_Strategy< SVC_HANDLER > *=0, ACE_Scheduling_Strategy< SVC_HANDLER > *=0, const ACE_TCHAR *service_name=0, const ACE_TCHAR *service_description=0, int use_select=1, int reuse_addr=1)
virtual | ~ACE_Strategy_Acceptor (void)
| Close down the Strategy_Acceptor's resources.
virtual | operator ACE_PEER_ACCEPTOR & () const
| Return the underlying PEER_ACCEPTOR object.
virtual ACE_PEER_ACCEPTOR & | acceptor (void) const
| Return the underlying PEER_ACCEPTOR object.
virtual ACE_HANDLE | get_handle (void) const
| Returns the listening acceptor's {ACE_HANDLE}.
void | dump (void) const
| Dump the state of an object.

## Public Attributes

| ACE_ALLOC_HOOK_DECLARE
| Declare the dynamic allocation hooks.

## Protected Member Functions

virtual int | suspend (void)
virtual int | resume (void)
virtual int | fini (void)
| Calls {handle_close} when dynamically unlinked.
virtual int | info (ACE_TCHAR **buf, size_t) const
| Default version returns address info in {buf}.
virtual int | make_svc_handler (SVC_HANDLER *&)
virtual int | accept_svc_handler (SVC_HANDLER *svc_handler)
virtual int | activate_svc_handler (SVC_HANDLER *svc_handler)
virtual int | handle_close (ACE_HANDLE=ACE_INVALID_HANDLE, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
virtual int | handle_signal (int signum, siginfo_t *, ucontext_t *)
| Handle SIGINT.

## Protected Attributes

CREATION_STRATEGY * | creation_strategy_
| Creation strategy for an Acceptor.
int | delete_creation_strategy_
ACCEPT_STRATEGY * | accept_strategy_
| Accept strategy for an {Acceptor}.
int | delete_accept_strategy_
CONCURRENCY_STRATEGY * | concurrency_strategy_
| Concurrency strategy for an {Acceptor}.
int | delete_concurrency_strategy_
SCHEDULING_STRATEGY * | scheduling_strategy_
| Scheduling strategy for an {Acceptor}.
int | delete_scheduling_strategy_
ACE_TCHAR * | service_name_
| Name of the service.
ACE_TCHAR * | service_description_
| Description of the service.
ACE_PEER_ACCEPTOR_ADDR | service_addr_

## Detailed Description

### template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
class ACE_Strategy_Acceptor< SVC_HANDLER, >

Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER.

Implements a flexible and extensible set of strategies for passively establishing connections with clients. There are three main strategies: (1) creating a SVC_HANDLER, (2) passively accepting a new connection from a client into the SVC_HANDLER, and (3) activating the SVC_HANDLER with a particular concurrency mechanism.

## Member Typedef Documentation

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
typedef ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> ACE_Strategy_Acceptor< SVC_HANDLER, >::ACCEPT_STRATEGY

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
typedef ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> ACE_Strategy_Acceptor< SVC_HANDLER, >::accept_strategy_type

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
typedef ACE_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2> ACE_Strategy_Acceptor< SVC_HANDLER, >::base_type

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, >::CONCURRENCY_STRATEGY

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, >::concurrency_strategy_type

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, >::CREATION_STRATEGY

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, >::creation_strategy_type

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
typedef ACE_Scheduling_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, >::SCHEDULING_STRATEGY

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
typedef ACE_Scheduling_Strategy<SVC_HANDLER> ACE_Strategy_Acceptor< SVC_HANDLER, >::scheduling_strategy_type

## Constructor & Destructor Documentation

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, >::ACE_Strategy_Acceptor | ( | const ACE_TCHAR | service_name[] = `0`,
|  | const ACE_TCHAR | service_description[] = `0`,
|  | int | use_select = `1`,
|  | int | reuse_addr = `1`
| ) |

| Default constructor.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, >::ACE_Strategy_Acceptor | ( | const ACE_PEER_ACCEPTOR_ADDR & | local_addr,
|  | ACE_Reactor * | = `ACE_Reactor::instance()`,
|  | ACE_Creation_Strategy< SVC_HANDLER > * | = `0`,
|  | ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > * | = `0`,
|  | ACE_Concurrency_Strategy< SVC_HANDLER > * | = `0`,
|  | ACE_Scheduling_Strategy< SVC_HANDLER > * | = `0`,
|  | const ACE_TCHAR | service_name[] = `0`,
|  | const ACE_TCHAR | service_description[] = `0`,
|  | int | use_select = `1`,
|  | int | reuse_addr = `1`
| ) |

| Initialize the appropriate strategies for creation, passive connection acceptance, and concurrency, and then register {this} with the Reactor and listen for connection requests at the designated {local_addr}.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, >::~ACE_Strategy_Acceptor | ( | void |  | ) | `[virtual]`

| Close down the Strategy_Acceptor's resources.

## Member Function Documentation

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::accept_svc_handler | ( | SVC_HANDLER * | svc_handler | ) | `[protected, virtual]`

| Bridge method for accepting the new connection into the {SVC_HANDLER}. The default behavior delegates to the {PEER_ACCEPTOR::accept} in the {Acceptor_Strategy}. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_PEER_ACCEPTOR & ACE_Strategy_Acceptor< SVC_HANDLER, >::acceptor | ( | void |  | ) | const`[virtual]`

| Return the underlying PEER_ACCEPTOR object. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::activate_svc_handler | ( | SVC_HANDLER * | svc_handler | ) | `[protected, virtual]`

Bridge method for activating a {SVC_HANDLER} with the appropriate concurrency strategy. The default behavior of this method is to activate the {SVC_HANDLER} by calling its {open} method (which allows the {SVC_HANDLER} to define its own concurrency strategy). However, subclasses can override this strategy to do more sophisticated concurrency activations (such as creating the {SVC_HANDLER} as an "active object" via multi-threading or multi-processing).

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
void ACE_Strategy_Acceptor< SVC_HANDLER, >::dump | ( | void |  | ) | const

| Dump the state of an object. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::fini | ( | void |  | ) | `[protected, virtual]`

| Calls {handle_close} when dynamically unlinked. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_HANDLE ACE_Strategy_Acceptor< SVC_HANDLER, >::get_handle | ( | void |  | ) | const`[virtual]`

| Returns the listening acceptor's {ACE_HANDLE}. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::handle_close | ( | ACE_HANDLE | = `ACE_INVALID_HANDLE`,
|  | ACE_Reactor_Mask | = `ACE_Event_Handler::ALL_EVENTS_MASK`
| ) | `[protected, virtual]`

| Perform termination activities when {this} is removed from the {Reactor}. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::handle_signal | ( | int | signum,
|  | siginfo_t * | ,
|  | ucontext_t * |
| ) | `[protected, virtual]`

| Handle SIGINT. Reimplemented from ACE_Event_Handler.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::info | ( | ACE_TCHAR ** | buf,
|  | size_t |
| ) | const`[protected, virtual]`

| Default version returns address info in {buf}. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::make_svc_handler | ( | SVC_HANDLER *& |  | ) | `[protected, virtual]`

Bridge method for creating a {SVC_HANDLER}. The strategy for creating a {SVC_HANDLER} are configured into the Acceptor via it's {creation_strategy_}. The default is to create a new {SVC_HANDLER} if {sh} == 0, else {sh} is unchanged. However, subclasses can override this policy to perform {SVC_HANDLER} creation in any way that they like (such as creating subclass instances of {SVC_HANDLER}, using a singleton, dynamically linking the handler, etc.). Returns -1 on failure, else 0.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::open | ( | const ACE_PEER_ACCEPTOR_ADDR & | ,
|  | ACE_Reactor * | = `ACE_Reactor::instance()`,
|  | ACE_Creation_Strategy< SVC_HANDLER > * | = `0`,
|  | ACE_Accept_Strategy< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 > * | = `0`,
|  | ACE_Concurrency_Strategy< SVC_HANDLER > * | = `0`,
|  | ACE_Scheduling_Strategy< SVC_HANDLER > * | = `0`,
|  | const ACE_TCHAR * | service_name = `0`,
|  | const ACE_TCHAR * | service_description = `0`,
|  | int | use_select = `1`,
|  | int | reuse_addr = `1`
| ) | `[virtual]`

| Initialize the appropriate strategies for creation, passive connection acceptance, and concurrency, and then register {this} with the Reactor and listen for connection requests at the designated {local_addr}.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::open | ( | const ACE_PEER_ACCEPTOR_ADDR & | local_addr,
|  | ACE_Reactor * | reactor,
|  | int | flags = `0`,
|  | int | use_select = `1`,
|  | int | reuse_addr = `1`
| ) | `[virtual]`

Open the contained `PEER_ACCEPTOR` object to begin listening, and register with the specified reactor for accept events.

The `PEER_ACCEPTOR` handle is put into non-blocking mode as a safeguard against the race condition that can otherwise occur between the time when the passive-mode socket handle is "ready" and when the actual `accept` call is made. During this interval, the client can shutdown the connection, in which case, the {accept} call can hang.

Parameters:

  | local_addr | The address to listen at.
  | reactor | Pointer to the ACE_Reactor instance to register this object with. The default is the singleton.
  | flags | Flags to control what mode an accepted socket will be put into after it is accepted. The only legal value for this argument is `ACE_NONBLOCK`, which enables non-blocking mode on the accepted peer stream object in `SVC_HANDLER`. The default is 0.
  | use_select | Affects behavior when called back by the reactor when a connection can be accepted. If non-zero, this object will accept all pending connections, intead of just the one that triggered the reactor callback. Uses ACE_OS::select() internally to detect any remaining acceptable connections. The default is 1.
  | reuse_addr | Passed to the `PEER_ACCEPTOR::open()` method with `local_addr`. Generally used to request that the OS allow reuse of the listen port. The default is 1.

Return values:

  | 0 | Success
  | -1 | Failure, `errno` contains an error code.

Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, >::operator ACE_PEER_ACCEPTOR & | ( |  | ) | const`[virtual]`

| Return the underlying PEER_ACCEPTOR object. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::resume | ( | void |  | ) | `[protected, virtual]`

| This method delegates to the {Scheduling_Strategy}'s {resume} method. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::suspend | ( | void |  | ) | `[protected, virtual]`

| This method delegates to the {Scheduling_Strategy}'s {suspend} method. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

## Member Data Documentation

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACCEPT_STRATEGY* ACE_Strategy_Acceptor< SVC_HANDLER, >::accept_strategy_`[protected]`

| Accept strategy for an {Acceptor}.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_Strategy_Acceptor< SVC_HANDLER, >::ACE_ALLOC_HOOK_DECLARE

| Declare the dynamic allocation hooks. Reimplemented from ACE_Acceptor< SVC_HANDLER, ACE_PEER_ACCEPTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
CONCURRENCY_STRATEGY* ACE_Strategy_Acceptor< SVC_HANDLER, >::concurrency_strategy_`[protected]`

| Concurrency strategy for an {Acceptor}.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
CREATION_STRATEGY* ACE_Strategy_Acceptor< SVC_HANDLER, >::creation_strategy_`[protected]`

| Creation strategy for an Acceptor.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::delete_accept_strategy_`[protected]`

| 1 if {Acceptor} created the accept strategy and thus should delete it, else 0.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::delete_concurrency_strategy_`[protected]`

| 1 if {Acceptor} created the concurrency strategy and thus should delete it, else 0.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::delete_creation_strategy_`[protected]`

| 1 if {Acceptor} created the creation strategy and thus should delete it, else 0.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
int ACE_Strategy_Acceptor< SVC_HANDLER, >::delete_scheduling_strategy_`[protected]`

| 1 if {Acceptor} created the scheduling strategy and thus should delete it, else 0.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
SCHEDULING_STRATEGY* ACE_Strategy_Acceptor< SVC_HANDLER, >::scheduling_strategy_`[protected]`

| Scheduling strategy for an {Acceptor}.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_PEER_ACCEPTOR_ADDR ACE_Strategy_Acceptor< SVC_HANDLER, >::service_addr_`[protected]`

| Address that the {Strategy_Acceptor} uses to listen for connections.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_TCHAR* ACE_Strategy_Acceptor< SVC_HANDLER, >::service_description_`[protected]`

| Description of the service.

template<class SVC_HANDLER, ACE_PEER_ACCEPTOR_1 >
ACE_TCHAR* ACE_Strategy_Acceptor< SVC_HANDLER, >::service_name_`[protected]`

| Name of the service.

The documentation for this class was generated from the following files:

- Acceptor.h
- Acceptor.cpp