# ACE_POSIX_Asynch_Operation Class Reference

This class implements <ace_asynch_operation> for all implementations of Proactor (AIOCB, SIG, SUN) Specific future implementations can derive from this class. More...

`#include <POSIX_Asynch_IO.h>`

Inheritance diagram for ACE_POSIX_Asynch_Operation:

[legend]
Collaboration diagram for ACE_POSIX_Asynch_Operation:

[legend]
List of all members.

## Public Member Functions

int | open (const ACE_Handler::Proxy_Ptr &handler_proxy, ACE_HANDLE handle, const void *completion_key, ACE_Proactor *proactor=0)
int | cancel (void)
| Check the documentation for <ACE_Asynch_Operation::cancel>.
ACE_Proactor * | proactor (void) const
| Return the underlying proactor.
ACE_POSIX_Proactor * | posix_proactor (void) const
| Return the underlying Proactor implementation.

## Protected Member Functions

| ACE_POSIX_Asynch_Operation (ACE_POSIX_Proactor *posix_proactor)
| Contructor.
virtual | ~ACE_POSIX_Asynch_Operation (void)
| Destructor.

## Protected Attributes

ACE_POSIX_Proactor * | posix_proactor_
ACE_Proactor * | proactor_
| Proactor that this Asynch IO will be registered with.
ACE_Handler::Proxy_Ptr | handler_proxy_
| Handler that will receive the callback.
ACE_HANDLE | handle_
| I/O handle used for reading.

## Detailed Description

This class implements <ace_asynch_operation> for all implementations of Proactor (AIOCB, SIG, SUN) Specific future implementations can derive from this class.

## Constructor & Destructor Documentation

ACE_POSIX_Asynch_Operation::ACE_POSIX_Asynch_Operation | ( | ACE_POSIX_Proactor * | posix_proactor | ) | `[protected]`

| Contructor.

ACE_POSIX_Asynch_Operation::~ACE_POSIX_Asynch_Operation | ( | void |  | ) | `[protected, virtual]`

| Destructor.

## Member Function Documentation

int ACE_POSIX_Asynch_Operation::cancel | ( | void |  | ) | `[virtual]`

| Check the documentation for <ACE_Asynch_Operation::cancel>. Implements ACE_Asynch_Operation_Impl. Reimplemented in ACE_POSIX_Asynch_Accept, and ACE_POSIX_Asynch_Connect.

int ACE_POSIX_Asynch_Operation::open | ( | const ACE_Handler::Proxy_Ptr & | handler_proxy,
|  | ACE_HANDLE | handle,
|  | const void * | completion_key,
|  | ACE_Proactor * | proactor = `0`
| ) | `[virtual]`

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. No need for the Proactor since the sub classes will know the correct implementation Proactor class, since this Operation class itself was created by the correct implementation Proactor class.

Implements ACE_Asynch_Operation_Impl.

Reimplemented in ACE_POSIX_Asynch_Accept, and ACE_POSIX_Asynch_Connect.

ACE_POSIX_Proactor * ACE_POSIX_Asynch_Operation::posix_proactor | ( | void |  | ) | const

| Return the underlying Proactor implementation.

ACE_Proactor * ACE_POSIX_Asynch_Operation::proactor | ( | void |  | ) | const`[virtual]`

| Return the underlying proactor. Implements ACE_Asynch_Operation_Impl.

## Member Data Documentation

ACE_HANDLE ACE_POSIX_Asynch_Operation::handle_ `[protected]`

| I/O handle used for reading.

ACE_Handler::Proxy_Ptr ACE_POSIX_Asynch_Operation::handler_proxy_ `[protected]`

| Handler that will receive the callback.

ACE_POSIX_Proactor* ACE_POSIX_Asynch_Operation::posix_proactor_ `[protected]`

| It is easy to get this specific implementation proactor here, since it is the one that creates the correct POSIX_Asynch_* objects. We can use this to get to the implementation proactor directly.

ACE_Proactor* ACE_POSIX_Asynch_Operation::proactor_ `[protected]`

| Proactor that this Asynch IO will be registered with.

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

- POSIX_Asynch_IO.h
- POSIX_Asynch_IO.cpp