# ACE_Asynch_Result Class Reference

An interface base class which allows users access to common information related to an asynchronous operation. More...

`#include <Asynch_IO.h>`

Inheritance diagram for ACE_Asynch_Result:

[legend]
Collaboration diagram for ACE_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
unsigned long | error (void) const
| Error value if the operation fails.
ACE_HANDLE | event (void) const
unsigned long | offset (void) const
unsigned long | offset_high (void) const
int | priority (void) const
int | signal_number (void) const
virtual | ~ACE_Asynch_Result (void)
| Destructor.

## Protected Member Functions

| ACE_Asynch_Result (ACE_Asynch_Result_Impl *implementation)
ACE_Asynch_Result_Impl * | implementation (void) const
| Get the implementation class.

## Protected Attributes

ACE_Asynch_Result_Impl * | implementation_
| Implementation class.

## Detailed Description

An interface base class which allows users access to common information related to an asynchronous operation.

An interface base class from which you can obtain some basic information like the number of bytes transferred, the ACT associated with the asynchronous operation, indication of success or failure, etc. Subclasses may want to store more information that is particular to the asynchronous operation it represents.

## Constructor & Destructor Documentation

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

| Destructor.

ACE_Asynch_Result::ACE_Asynch_Result | ( | ACE_Asynch_Result_Impl * | implementation | ) | `[protected]`

| Constructor. This implementation will not be deleted. The implementation will be deleted by the Proactor.

## Member Function Documentation

const void * ACE_Asynch_Result::act | ( | void |  | ) | const

| ACT associated with the operation.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL size_t ACE_Asynch_Result::bytes_transferred | ( | void |  | ) | const

| Number of bytes transferred by the operation.

const void * ACE_Asynch_Result::completion_key | ( | void |  | ) | const

| This is the ACT associated with the handle on which the Asynch_Operation takes place. On WIN32, this returns the ACT associated with the handle when it was registered with the I/O completion port. @ This is not implemented for POSIX4 platforms. Returns 0.

unsigned long ACE_Asynch_Result::error | ( | void |  | ) | const

| Error value if the operation fails.

ACE_HANDLE ACE_Asynch_Result::event | ( | void |  | ) | const

| On WIN32, this returns the event associated with the OVERLAPPED structure. This returns ACE_INVALID_HANDLE on POSIX4-Unix platforms.

ACE_Asynch_Result_Impl * ACE_Asynch_Result::implementation | ( | void |  | ) | const`[protected]`

| Get the implementation class. Reimplemented in ACE_Asynch_Read_Stream::Result, ACE_Asynch_Write_Stream::Result, ACE_Asynch_Read_File::Result, ACE_Asynch_Write_File::Result, ACE_Asynch_Accept::Result, ACE_Asynch_Connect::Result, ACE_Asynch_Transmit_File::Result, ACE_Asynch_Read_Dgram::Result, and ACE_Asynch_Write_Dgram::Result.

unsigned long ACE_Asynch_Result::offset | ( | void |  | ) | const

| This really makes sense only when doing file I/O. On WIN32, these are represented in the OVERLAPPED datastructure. @ On POSIX4-Unix, offset_high should be supported using aiocb64.

unsigned long ACE_Asynch_Result::offset_high | ( | void |  | ) | const

int ACE_Asynch_Result::priority | ( | void |  | ) | const

| Priority of the operation. On POSIX4-Unix, this is supported. Priority 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 is a no-op.

int ACE_Asynch_Result::signal_number | ( | void |  | ) | const

| POSIX4 real-time signal number to be used for the operation. {signal_number} ranges from ACE_SIGRTMIN to ACE_SIGRTMAX. By default, ACE_SIGRTMIN is used to issue {aio_} calls. This is a no-op on non-POSIX4 systems and returns 0.

int ACE_Asynch_Result::success | ( | void |  | ) | const

| Did the operation succeed?

## Member Data Documentation

ACE_Asynch_Result_Impl* ACE_Asynch_Result::implementation_`[protected]`

| Implementation class. Reimplemented in ACE_Asynch_Read_Stream::Result, ACE_Asynch_Write_Stream::Result, ACE_Asynch_Read_File::Result, ACE_Asynch_Write_File::Result, ACE_Asynch_Accept::Result, ACE_Asynch_Connect::Result, ACE_Asynch_Transmit_File::Result, ACE_Asynch_Read_Dgram::Result, and ACE_Asynch_Write_Dgram::Result.

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

- Asynch_IO.h
- Asynch_IO.cpp