Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# ACE_POSIX_Asynch_Accept Class Reference

`#include <POSIX_Asynch_IO.h>`

Inheritance diagram for ACE_POSIX_Asynch_Accept:

[legend]
Collaboration diagram for ACE_POSIX_Asynch_Accept:

[legend]
List of all members.

## Public Methods
| ACE_POSIX_Asynch_Accept (ACE_POSIX_Proactor *posix_proactor)
| Constructor. More...
int | open (ACE_Handler &handler, ACE_HANDLE handle, const void *completion_key, ACE_Proactor *proactor=0)
int | accept (ACE_Message_Block &message_block, u_long bytes_to_read, ACE_HANDLE accept_handle, const void *act, int priority, int signal_number=0)
virtual | ~ACE_POSIX_Asynch_Accept (void)
| Destructor. More...
int | cancel (void)
int | close (int flg_notify)
ACE_Proactor * | proactor (void) const
| Return the underlying proactor. More...
## Static Private Methods
void * | thread_function (void *reactor)
| The thread function that does handle events. More...
## Private Attributes
ACE_Reactor | reactor_
| Reactor to wait on the <listen_handle>. More...
ACE_POSIX_Asynch_Accept_Handler * | accept_handler_
| The Event Handler to do handle_input. More...
int | grp_id_
| group id for the thread that we create for accepts. More...
ACE_POSIX_Proactor * | posix_proactor_
| POSIX Proactor implementation. More...

## Constructor & Destructor Documentation

ACE_POSIX_Asynch_Accept::ACE_POSIX_Asynch_Accept | ( | ACE_POSIX_Proactor * | posix_proactor | ) |

| Constructor.

ACE_POSIX_Asynch_Accept::~ACE_POSIX_Asynch_Accept | ( | void |  | ) | `[virtual]`

| Destructor.

## Member Function Documentation

int ACE_POSIX_Asynch_Accept::accept | ( | ACE_Message_Block & | message_block,
|  | u_long | bytes_to_read,
|  | ACE_HANDLE | accept_handle,
|  | const void * | act,
|  | int | priority,
|  | int | signal_number = 0
| ) |

| This starts off an asynchronous accept. The asynchronous accept call also allows any initial data to be returned to the <handler>. Upto <bytes_to_read> will be read and stored in the <message_block>. The <accept_handle> will be used for the <accept> call. If (<accept_handle> == INVALID_HANDLE), a new handle will be created. <message_block> must be specified. This is because the address of the new connection is placed at the end of this buffer.

int ACE_POSIX_Asynch_Accept::cancel | ( | void |  | ) |

| Cancel all pending pseudo-asynchronus requests Behavior as usual AIO request Reimplemented from ACE_POSIX_Asynch_Operation.

int ACE_POSIX_Asynch_Accept::close | ( | int | flg_notify | ) |

| Close performs cancellation of all pending requests Parameter flg_notify can be 0 - don't send notifications about canceled accepts 1 - notify user about canceled accepts according POSIX standards we should receive notifications on canceled AIO requests

int ACE_POSIX_Asynch_Accept::open | ( | ACE_Handler & | handler,
|  | ACE_HANDLE | handle,
|  | const void * | completion_key,
|  | ACE_Proactor * | proactor = 0
| ) |

| This <open> belongs to ACE_AIOCB_Asynch_Operation. We forward this call to that method. We have put this here to avoid the compiler warnings. Reimplemented from ACE_POSIX_Asynch_Operation.

ACE_Proactor * ACE_POSIX_Asynch_Accept::proactor | ( | void |  | ) | const

| Return the underlying proactor. Reimplemented from ACE_POSIX_Asynch_Operation.

void * ACE_POSIX_Asynch_Accept::thread_function | ( | void * | arg_reactor | ) | `[static, private]`

| The thread function that does handle events.

## Member Data Documentation

ACE_POSIX_Asynch_Accept_Handler* ACE_POSIX_Asynch_Accept::accept_handler_`[private]`

| The Event Handler to do handle_input.

int ACE_POSIX_Asynch_Accept::grp_id_`[private]`

| group id for the thread that we create for accepts.

ACE_POSIX_Proactor* ACE_POSIX_Asynch_Accept::posix_proactor_`[private]`

| POSIX Proactor implementation.

ACE_Reactor ACE_POSIX_Asynch_Accept::reactor_`[private]`

| Reactor to wait on the <listen_handle>.

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

- POSIX_Asynch_IO.h
- POSIX_Asynch_IO.cpp