# ACE_Strategy_Connector< SVC_HANDLER, > Class Template Reference

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

`#include <Connector.h>`

Inheritance diagram for ACE_Strategy_Connector< SVC_HANDLER, >:

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

[legend]
List of all members.

## Public Types

typedef ACE_Creation_Strategy< SVC_HANDLER > | creation_strategy_type
typedef ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > | connect_strategy_type
typedef ACE_Concurrency_Strategy< SVC_HANDLER > | concurrency_strategy_type
typedef ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > | base_type
typedef ACE_Creation_Strategy< SVC_HANDLER > | CREATION_STRATEGY
typedef ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > | CONNECT_STRATEGY
typedef ACE_Concurrency_Strategy< SVC_HANDLER > | CONCURRENCY_STRATEGY
typedef ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > | SUPER

## Public Member Functions

| ACE_Strategy_Connector (ACE_Reactor *r=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > *=0, ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > *=0, ACE_Concurrency_Strategy< SVC_HANDLER > *=0, int flags=0)
virtual int | open (ACE_Reactor *r, int flags)
virtual int | open (ACE_Reactor *r=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > *=0, ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > *=0, ACE_Concurrency_Strategy< SVC_HANDLER > *=0, int flags=0)
virtual | ~ACE_Strategy_Connector (void)
| Shutdown a connector and release resources.
virtual int | close (void)
| Close down the Connector.
virtual ACE_Creation_Strategy< SVC_HANDLER > * | creation_strategy (void) const
virtual ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > * | connect_strategy (void) const
virtual ACE_Concurrency_Strategy< SVC_HANDLER > * | concurrency_strategy (void) const

## Protected Member Functions

virtual int | make_svc_handler (SVC_HANDLER *&sh)
virtual int | connect_svc_handler (SVC_HANDLER *&sh, const ACE_PEER_CONNECTOR_ADDR &remote_addr, ACE_Time_Value *timeout, const ACE_PEER_CONNECTOR_ADDR &local_addr, int reuse_addr, int flags, int perms)
virtual int | connect_svc_handler (SVC_HANDLER *&sh, SVC_HANDLER *&sh_copy, const ACE_PEER_CONNECTOR_ADDR &remote_addr, ACE_Time_Value *timeout, const ACE_PEER_CONNECTOR_ADDR &local_addr, int reuse_addr, int flags, int perms)
virtual int | activate_svc_handler (SVC_HANDLER *svc_handler)

## Protected Attributes

CREATION_STRATEGY * | creation_strategy_
| Creation strategy for an <connector>.
int | delete_creation_strategy_
CONNECT_STRATEGY * | connect_strategy_
| Connect strategy for a <connector>.
int | delete_connect_strategy_
CONCURRENCY_STRATEGY * | concurrency_strategy_
| Concurrency strategy for an <connector>.
int | delete_concurrency_strategy_

## Detailed Description

### template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
class ACE_Strategy_Connector< SVC_HANDLER, >

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

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

## Member Typedef Documentation

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
typedef ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2> ACE_Strategy_Connector< SVC_HANDLER, >::base_type

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Connector< SVC_HANDLER, >::CONCURRENCY_STRATEGY

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
typedef ACE_Concurrency_Strategy<SVC_HANDLER> ACE_Strategy_Connector< SVC_HANDLER, >::concurrency_strategy_type

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> ACE_Strategy_Connector< SVC_HANDLER, >::CONNECT_STRATEGY

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
typedef ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2> ACE_Strategy_Connector< SVC_HANDLER, >::connect_strategy_type

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Connector< SVC_HANDLER, >::CREATION_STRATEGY

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
typedef ACE_Creation_Strategy<SVC_HANDLER> ACE_Strategy_Connector< SVC_HANDLER, >::creation_strategy_type

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
typedef ACE_Connector<SVC_HANDLER, ACE_PEER_CONNECTOR_2> ACE_Strategy_Connector< SVC_HANDLER, >::SUPER

## Constructor & Destructor Documentation

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
ACE_Strategy_Connector< SVC_HANDLER, >::ACE_Strategy_Connector | ( | ACE_Reactor * | r = `ACE_Reactor::instance()`,
|  | ACE_Creation_Strategy< SVC_HANDLER > * | = `0`,
|  | ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > * | = `0`,
|  | ACE_Concurrency_Strategy< SVC_HANDLER > * | = `0`,
|  | int | flags = `0`
| ) |

| Initialize a connector. flags indicates how <svc_handler>'s should be initialized prior to being activated. Right now, the only flag that is processed is ACE_NONBLOCK, which enabled non-blocking I/O on the <svc_handler> when it is opened.

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

| Shutdown a connector and release resources.

## Member Function Documentation

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< 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_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< SVC_HANDLER, >::close | ( | void |  | ) | `[virtual]`

| Close down the Connector. Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
ACE_Concurrency_Strategy< SVC_HANDLER > * ACE_Strategy_Connector< SVC_HANDLER, >::concurrency_strategy | ( | void |  | ) | const`[virtual]`

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > * ACE_Strategy_Connector< SVC_HANDLER, >::connect_strategy | ( | void |  | ) | const`[virtual]`

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< SVC_HANDLER, >::connect_svc_handler | ( | SVC_HANDLER *& | sh,
|  | SVC_HANDLER *& | sh_copy,
|  | const ACE_PEER_CONNECTOR_ADDR & | remote_addr,
|  | ACE_Time_Value * | timeout,
|  | const ACE_PEER_CONNECTOR_ADDR & | local_addr,
|  | int | reuse_addr,
|  | int | flags,
|  | int | perms
| ) | `[protected, virtual]`

Bridge method for connecting the new connection into the <svc_handler>. The default behavior delegates to the <PEER_CONNECTOR::connect> in the <connect_strategy>. <sh_copy> is used to obtain a copy of the <sh> pointer, but that can be kept in the stack; the motivation is a bit too long to include here, but basically we want to modify <sh> safely, using the internal locks in the Connect_Strategy, while saving a TSS copy in <sh_copy>, usually located in the stack.

Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< SVC_HANDLER, >::connect_svc_handler | ( | SVC_HANDLER *& | sh,
|  | const ACE_PEER_CONNECTOR_ADDR & | remote_addr,
|  | ACE_Time_Value * | timeout,
|  | const ACE_PEER_CONNECTOR_ADDR & | local_addr,
|  | int | reuse_addr,
|  | int | flags,
|  | int | perms
| ) | `[protected, virtual]`

| Bridge method for connecting the new connection into the <svc_handler>. The default behavior delegates to the <PEER_CONNECTOR::connect> in the <connect_strategy>. Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
ACE_Creation_Strategy< SVC_HANDLER > * ACE_Strategy_Connector< SVC_HANDLER, >::creation_strategy | ( | void |  | ) | const`[virtual]`

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< SVC_HANDLER, >::make_svc_handler | ( | SVC_HANDLER *& | sh | ) | `[protected, virtual]`

Bridge method for creating a <svc_handler>. The strategy for creating a <svc_handler> are configured into the Connector via it's <creation_strategy_>. The default is to create a new <svc_handler> only 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 if failure, else 0.

Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< SVC_HANDLER, >::open | ( | ACE_Reactor * | r = `ACE_Reactor::instance()`,
|  | ACE_Creation_Strategy< SVC_HANDLER > * | = `0`,
|  | ACE_Connect_Strategy< SVC_HANDLER, ACE_PEER_CONNECTOR_2 > * | = `0`,
|  | ACE_Concurrency_Strategy< SVC_HANDLER > * | = `0`,
|  | int | flags = `0`
| ) | `[virtual]`

| Initialize a connector. flags indicates how <svc_handler>'s should be initialized prior to being activated. Right now, the only flag that is processed is ACE_NONBLOCK, which enabled non-blocking I/O on the <svc_handler> when it is opened.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< SVC_HANDLER, >::open | ( | ACE_Reactor * | r,
|  | int | flags
| ) | `[virtual]`

| Initialize a connector. flags indicates how <svc_handler>'s should be initialized prior to being activated. Right now, the only flag that is processed is ACE_NONBLOCK, which enabled non-blocking I/O on the <svc_handler> when it is opened. Default strategies would be created and used. Reimplemented from ACE_Connector< SVC_HANDLER, ACE_PEER_CONNECTOR_2 >.

## Member Data Documentation

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
CONCURRENCY_STRATEGY* ACE_Strategy_Connector< SVC_HANDLER, >::concurrency_strategy_ `[protected]`

| Concurrency strategy for an <connector>.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
CONNECT_STRATEGY* ACE_Strategy_Connector< SVC_HANDLER, >::connect_strategy_ `[protected]`

| Connect strategy for a <connector>.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
CREATION_STRATEGY* ACE_Strategy_Connector< SVC_HANDLER, >::creation_strategy_ `[protected]`

| Creation strategy for an <connector>.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< SVC_HANDLER, >::delete_concurrency_strategy_ `[protected]`

| 1 if <connector> created the concurrency strategy and thus should delete it, else 0.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< SVC_HANDLER, >::delete_connect_strategy_ `[protected]`

| 1 if <connector> created the connect strategy and thus should delete it, else 0.

template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1 >
int ACE_Strategy_Connector< SVC_HANDLER, >::delete_creation_strategy_ `[protected]`

| 1 if <connector> created the creation strategy and thus should delete it, else 0.

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

- Connector.h
- Connector.cpp