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.
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.
int | cancel (void)
int | close ( int flg_notify)
ACE_Proactor* | proactor (void) const
| Return the underlying proactor.
## Private Attributes
ACE_Reactor | reactor_
| Reactor to wait on the <listen_handle>.
ACE_POSIX_Asynch_Accept_Handler* | accept_handler_
| The Event Handler to do handle_input.
int | grp_id_
| group id for the thread that we create for accepts.
ACE_POSIX_Proactor* | posix_proactor_
| POSIX Proactor implementation.
## Static Private Methods
void* | thread_function (void* reactor)
| The thread function that does handle events.

## 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 will be used for the call. If ( == 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 * 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