ACE_Asynch_Accept Class Reference

This class is a factory for starting off asynchronous accepts on a listen handle. This class forwards all methods to its implementation class. More...

#include <Asynch_IO.h>

Inheritance diagram for ACE_Asynch_Accept:

Inheritance graph
Collaboration diagram for ACE_Asynch_Accept:

Collaboration graph
List of all members.

Public Member Functions

 ACE_Asynch_Accept (void)
 A do nothing constructor.

virtual ~ACE_Asynch_Accept (void)

int open (ACE_Handler &handler, ACE_HANDLE handle=ACE_INVALID_HANDLE, const void *completion_key=0, ACE_Proactor *proactor=0)
int accept (ACE_Message_Block &message_block, size_t bytes_to_read, ACE_HANDLE accept_handle=ACE_INVALID_HANDLE, const void *act=0, int priority=0, int signal_number=ACE_SIGRTMIN, int addr_family=AF_INET)
virtual ACE_Asynch_Operation_Implimplementation (void) const
 Return the underlying implementation class.

Protected Attributes


Detailed Description

This class is a factory for starting off asynchronous accepts on a listen handle. This class forwards all methods to its implementation class.

Once {open} is called, multiple asynchronous {accept}s can started using this class. A ACE_Asynch_Accept::Result will be passed back to the {handler} when the asynchronous accept completes through the {ACE_Handler::handle_accept} callback.

Definition at line 814 of file Asynch_IO.h.

Constructor & Destructor Documentation

ACE_Asynch_Accept::ACE_Asynch_Accept void   ) 

A do nothing constructor.

Definition at line 556 of file Asynch_IO.cpp.

00557   : implementation_ (0)
00558 {
00559 }

ACE_Asynch_Accept::~ACE_Asynch_Accept void   )  [virtual]


Definition at line 561 of file Asynch_IO.cpp.

00562 {
00563   // Delete the implementation.
00564   delete this->implementation_;
00565   this->implementation_ = 0;
00566 }

Member Function Documentation

int ACE_Asynch_Accept::accept ACE_Message_Block message_block,
size_t  bytes_to_read,
const void *  act = 0,
int  priority = 0,
int  signal_number = ACE_SIGRTMIN,
int  addr_family = AF_INET

This starts off an asynchronous accept. The asynchronous accept call also allows any initial data to be returned to the handler specified to open().

message_block A message block to receive initial data, as well as the local and remote addresses when the connection is made. Since the block receives the addresses regardless of whether or not initial data is available or requested, the message block size must be at least bytes_to_read plus two times the size of the addresses used (IPv4 or IPv6).
bytes_to_read The maximum number of bytes of initial data to read into message_block.
accept_handle The handle that the new connection will be accepted on. If INVALID_HANDLE, a new handle will be created using addr_family.
act Value to be passed in result when operation completes.
priority Priority of the operation. On POSIX4-Unix, this is supported. Works like nice in Unix. Negative values are not allowed. 0 means priority of the operation same as the process priority. 1 means priority of the operation is one less than process. And so forth. On Win32, this argument is ignored.
signal_number The POSIX4 real-time signal number to be used for the operation. Value range is from ACE_SIGRTMIN to ACE_SIGRTMAX. This argument is ignored on non-POSIX4 systems.
addr_family The address family to use if accept_handle is ACE_INVALID_HANDLE and a new handle must be opened. Values are AF_INET and PF_INET6.

Definition at line 589 of file Asynch_IO.cpp.

References ACE_Asynch_Accept_Impl::accept().

Referenced by ACE_Asynch_Acceptor< HANDLER >::accept().

00596 {
00597   return this->implementation_->accept (message_block,
00598                                         bytes_to_read,
00599                                         accept_handle,
00600                                         act,
00601                                         priority,
00602                                         signal_number,
00603                                         addr_family);
00604 }

ACE_Asynch_Operation_Impl * ACE_Asynch_Accept::implementation void   )  const [virtual]

Return the underlying implementation class.

Implements ACE_Asynch_Operation.

Definition at line 607 of file Asynch_IO.cpp.

00608 {
00609   return this->implementation_;
00610 }

int ACE_Asynch_Accept::open ACE_Handler handler,
const void *  completion_key = 0,
ACE_Proactor proactor = 0

Initializes the factory with information which will be used with each asynchronous call. If ({handle} == ACE_INVALID_HANDLE), {ACE_Handler::handle} will be called on the {handler} to get the correct handle.

Reimplemented from ACE_Asynch_Operation.

Definition at line 569 of file Asynch_IO.cpp.

References ACE_Proactor::create_asynch_accept(), ACE_Asynch_Operation::get_proactor(), and ACE_Asynch_Operation::open().

Referenced by ACE_Asynch_Acceptor< HANDLER >::open(), and ACE_Asynch_Acceptor< HANDLER >::set_handle().

00573 {
00574   // Get a proactor for/from the user.
00575   proactor = this->get_proactor (proactor, handler);
00577   // Now let us get the implementation initialized.
00578   if ((this->implementation_ = proactor->create_asynch_accept ()) == 0)
00579     return -1;
00581   // Call the <open> method of the base class.
00582   return ACE_Asynch_Operation::open (handler,
00583                                      handle,
00584                                      completion_key,
00585                                      proactor);
00586 }

Member Data Documentation

ACE_Asynch_Accept_Impl* ACE_Asynch_Accept::implementation_ [protected]

Delegation/implementation class that all methods will be forwarded to.

Definition at line 884 of file Asynch_IO.h.

The documentation for this class was generated from the following files:
Generated on Thu Nov 9 11:19:17 2006 for ACE by doxygen 1.3.6