# ACE_POSIX_Asynch_Result Class Reference

`#include <POSIX_Asynch_IO.h>`

Inheritance diagram for ACE_POSIX_Asynch_Result:

[legend]
Collaboration diagram for ACE_POSIX_Asynch_Result:

[legend]
List of all members.

## Public Member Functions

size_t | bytes_transferred (void) const
| Number of bytes transferred by the operation.
const void * | act (void) const
| ACT associated with the operation.
int | success (void) const
| Did the operation succeed?
const void * | completion_key (void) const
u_long | error (void) const
| Error value if the operation fail.
ACE_HANDLE | event (void) const
| This returns ACE_INVALID_HANDLE on POSIX4 platforms.
u_long | offset (void) const
u_long | offset_high (void) const
int | priority (void) const
| Priority of the operation.
int | signal_number (void) const
int | post_completion (ACE_Proactor_Impl *proactor)
| Post <this> to the Proactor.
virtual | ~ACE_POSIX_Asynch_Result (void)
| Destructor.
void | set_error (u_long errcode)
| Simulate error value to use in the post_completion ().
void | set_bytes_transferred (size_t nbytes)
| Simulate value to use in the post_completion ().

## Protected Member Functions

| ACE_POSIX_Asynch_Result (const ACE_Handler::Proxy_Ptr &handler_proxy, const void *act, ACE_HANDLE event, u_long offset, u_long offset_high, int priority, int signal_number)
| Constructor. <event> is not used on POSIX.

## Protected Attributes

ACE_Handler::Proxy_Ptr | handler_proxy_
| Handler that will be called back.
const void * | act_
size_t | bytes_transferred_
| Bytes transferred by this operation.
int | success_
| Success indicator.
const void * | completion_key_
| ACT associated with handle.
u_long | error_
| Error if operation failed.

## Detailed Description

This class provides concrete implementation for ACE_Asynch_Result for POSIX4 platforms. This class extends `aiocb` and makes it more useful.

## Constructor & Destructor Documentation

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

| Destructor.

ACE_POSIX_Asynch_Result::ACE_POSIX_Asynch_Result | ( | const ACE_Handler::Proxy_Ptr & | handler_proxy,
|  | const void * | act,
|  | ACE_HANDLE | event,
|  | u_long | offset,
|  | u_long | offset_high,
|  | int | priority,
|  | int | signal_number
| ) | `[protected]`

| Constructor. <event> is not used on POSIX.

## Member Function Documentation

const void * ACE_POSIX_Asynch_Result::act | ( | void |  | ) | const`[virtual]`

| ACT associated with the operation. Implements ACE_Asynch_Result_Impl.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL size_t ACE_POSIX_Asynch_Result::bytes_transferred | ( | void |  | ) | const`[virtual]`

| Number of bytes transferred by the operation. Implements ACE_Asynch_Result_Impl.

const void * ACE_POSIX_Asynch_Result::completion_key | ( | void |  | ) | const`[virtual]`

| This is the ACT associated with the handle on which the Asynch_Operation takes place. @ This is not implemented for POSIX4 platforms. Implements ACE_Asynch_Result_Impl.

u_long ACE_POSIX_Asynch_Result::error | ( | void |  | ) | const`[virtual]`

| Error value if the operation fail. Implements ACE_Asynch_Result_Impl.

ACE_HANDLE ACE_POSIX_Asynch_Result::event | ( | void |  | ) | const`[virtual]`

| This returns ACE_INVALID_HANDLE on POSIX4 platforms. Implements ACE_Asynch_Result_Impl.

u_long ACE_POSIX_Asynch_Result::offset | ( | void |  | ) | const`[virtual]`

| This really make sense only when doing file I/O. @ On POSIX4-Unix, offset_high should be supported using aiocb64. Implements ACE_Asynch_Result_Impl.

u_long ACE_POSIX_Asynch_Result::offset_high | ( | void |  | ) | const`[virtual]`

| Implements ACE_Asynch_Result_Impl.

int ACE_POSIX_Asynch_Result::post_completion | ( | ACE_Proactor_Impl * | proactor | ) | `[virtual]`

| Post <this> to the Proactor. Implements ACE_Asynch_Result_Impl.

int ACE_POSIX_Asynch_Result::priority | ( | void |  | ) | const`[virtual]`

| Priority of the operation. Implements ACE_Asynch_Result_Impl.

void ACE_POSIX_Asynch_Result::set_bytes_transferred | ( | size_t | nbytes | ) |

| Simulate value to use in the post_completion ().

void ACE_POSIX_Asynch_Result::set_error | ( | u_long | errcode | ) |

| Simulate error value to use in the post_completion ().

int ACE_POSIX_Asynch_Result::signal_number | ( | void |  | ) | const`[virtual]`

| POSIX4 realtime signal number to be used for the operation. <signal_number> ranges from SIGRTMIN to SIGRTMAX. By default, SIGRTMIN is used to issue <aio_> calls. Implements ACE_Asynch_Result_Impl.

int ACE_POSIX_Asynch_Result::success | ( | void |  | ) | const`[virtual]`

| Did the operation succeed? Implements ACE_Asynch_Result_Impl.

## Member Data Documentation

const void* ACE_POSIX_Asynch_Result::act_`[protected]`

| ACT for this operation. We could use <aiocb::aio_sigevent.sigev_value.sival_ptr> for this. But it doesnot provide the constness, so this may be better.

size_t ACE_POSIX_Asynch_Result::bytes_transferred_`[protected]`

| Bytes transferred by this operation.

const void* ACE_POSIX_Asynch_Result::completion_key_`[protected]`

| ACT associated with handle.

u_long ACE_POSIX_Asynch_Result::error_`[protected]`

| Error if operation failed.

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

| Handler that will be called back.

int ACE_POSIX_Asynch_Result::success_`[protected]`

| Success indicator.

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

- POSIX_Asynch_IO.h
- POSIX_Asynch_IO.cpp