Abstract factory for creating a service handler (SVC_HANDLER), accepting into the SVC_HANDLER, and activating the SVC_HANDLER.
More...
|
| typedef ACE_Creation_Strategy< SVC_HANDLER > | creation_strategy_type |
| |
| typedef ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR > | 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, PEER_ACCEPTOR > | base_type |
| |
| typedef ACE_Creation_Strategy< SVC_HANDLER > | CREATION_STRATEGY |
| |
| typedef ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR > | ACCEPT_STRATEGY |
| |
| typedef ACE_Concurrency_Strategy< SVC_HANDLER > | CONCURRENCY_STRATEGY |
| |
| typedef ACE_Scheduling_Strategy< SVC_HANDLER > | SCHEDULING_STRATEGY |
| |
| typedef PEER_ACCEPTOR::PEER_ADDR | addr_type |
| |
| typedef PEER_ACCEPTOR | acceptor_type |
| |
| typedef SVC_HANDLER | handler_type |
| |
| typedef SVC_HANDLER::stream_type | stream_type |
| |
| enum | {
LO_PRIORITY = 0,
HI_PRIORITY = 10,
NULL_MASK = 0,
READ_MASK = (1 << 0),
WRITE_MASK = (1 << 1),
EXCEPT_MASK = (1 << 2),
ACCEPT_MASK = (1 << 3),
CONNECT_MASK = (1 << 4),
TIMER_MASK = (1 << 5),
QOS_MASK = (1 << 6),
GROUP_QOS_MASK = (1 << 7),
SIGNAL_MASK = (1 << 8),
ALL_EVENTS_MASK,
RWE_MASK,
DONT_CALL = (1 << 9)
} |
| |
| enum | { ACE_EVENT_HANDLER_NOT_RESUMED = -1,
ACE_REACTOR_RESUMES_HANDLER = 0,
ACE_APPLICATION_RESUMES_HANDLER
} |
| |
| typedef long | Reference_Count |
| | Reference count type. More...
|
| |
|
| | 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. More...
|
| |
| | ACE_Strategy_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, ACE_Reactor *=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > *=0, ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR > *=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 typename PEER_ACCEPTOR::PEER_ADDR &local_addr, ACE_Reactor *reactor, int flags=0, int use_select=1, int reuse_addr=1) |
| |
| virtual int | open (const typename PEER_ACCEPTOR::PEER_ADDR &, ACE_Reactor *=ACE_Reactor::instance(), ACE_Creation_Strategy< SVC_HANDLER > *=0, ACE_Accept_Strategy< SVC_HANDLER, PEER_ACCEPTOR > *=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. More...
|
| |
| virtual | operator PEER_ACCEPTOR & () const |
| | Return the underlying PEER_ACCEPTOR object. More...
|
| |
| virtual PEER_ACCEPTOR & | acceptor (void) const |
| | Return the underlying PEER_ACCEPTOR object. More...
|
| |
| virtual ACE_HANDLE | get_handle (void) const |
| | Returns the listening acceptor's {ACE_HANDLE}. More...
|
| |
| void | dump (void) const |
| | Dump the state of an object. More...
|
| |
| virtual int | suspend (void) |
| |
| virtual int | resume (void) |
| |
| | ACE_Acceptor (ACE_Reactor *=0, int use_select=1) |
| | "Do-nothing" constructor. More...
|
| |
| | ACE_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, ACE_Reactor *reactor=ACE_Reactor::instance(), int flags=0, int use_select=1, int reuse_addr=1) |
| |
| virtual | ~ACE_Acceptor (void) |
| | Close down the Acceptor's resources. More...
|
| |
| virtual int | close (void) |
| | Close down the Acceptor. More...
|
| |
| virtual int | handle_accept_error (void) |
| |
| void | dump (void) const |
| | Dump the state of an object. More...
|
| |
| | ACE_Service_Object (ACE_Reactor *=0) |
| | Constructor. More...
|
| |
| virtual | ~ACE_Service_Object (void) |
| | Destructor. More...
|
| |
| virtual | ~ACE_Event_Handler (void) |
| | Destructor is virtual to enable proper cleanup. More...
|
| |
| virtual void | set_handle (ACE_HANDLE) |
| | Set the I/O handle. More...
|
| |
| virtual int | priority (void) const |
| |
| virtual void | priority (int priority) |
| | Set the priority of the Event_Handler. More...
|
| |
| virtual int | handle_output (ACE_HANDLE fd=ACE_INVALID_HANDLE) |
| |
| virtual int | handle_exception (ACE_HANDLE fd=ACE_INVALID_HANDLE) |
| | Called when an exceptional events occur (e.g., SIGURG). More...
|
| |
| virtual int | handle_timeout (const ACE_Time_Value ¤t_time, const void *act=0) |
| |
| virtual int | handle_exit (ACE_Process *) |
| | Called when a process exits. More...
|
| |
| virtual int | resume_handler (void) |
| |
| virtual int | handle_qos (ACE_HANDLE=ACE_INVALID_HANDLE) |
| |
| virtual int | handle_group_qos (ACE_HANDLE=ACE_INVALID_HANDLE) |
| |
| virtual void | reactor (ACE_Reactor *reactor) |
| | Set the event demultiplexors. More...
|
| |
| virtual ACE_Reactor * | reactor (void) const |
| | Get the event demultiplexors. More...
|
| |
| virtual ACE_Reactor_Timer_Interface * | reactor_timer_interface (void) const |
| | Get only the reactor's timer related interface. More...
|
| |
| virtual Reference_Count | add_reference (void) |
| | Increment reference count on the handler. More...
|
| |
| virtual Reference_Count | remove_reference (void) |
| | Decrement reference count on the handler. More...
|
| |
| Reference_Counting_Policy & | reference_counting_policy (void) |
| | Current Reference_Counting_Policy. More...
|
| |
| | ACE_Shared_Object (void) |
| | Constructor. More...
|
| |
| virtual | ~ACE_Shared_Object (void) |
| | Destructor. More...
|
| |
template<typename SVC_HANDLER, typename PEER_ACCEPTOR>
class ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >
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.
template<typename SVC_HANDLER , typename PEER_ACCEPTOR >
| int ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::activate_svc_handler |
( |
SVC_HANDLER * |
svc_handler | ) |
|
|
protectedvirtual |
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, PEER_ACCEPTOR >.
template<typename SVC_HANDLER , typename PEER_ACCEPTOR >
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, PEER_ACCEPTOR >.
template<typename SVC_HANDLER , typename PEER_ACCEPTOR >
| int ACE_Strategy_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >::open |
( |
const typename PEER_ACCEPTOR::PEER_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, instead 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, PEER_ACCEPTOR >.
Public Member Functions inherited from ACE_Acceptor< SVC_HANDLER, PEER_ACCEPTOR >
1.8.9.1
