---
name: "ACE_POSIX_Asynch_Result"
section: "3"
platform: "linux"
package: "libace-doc"
version: "5.0.7-4"
release: "Debian 2.2 (Potato)"
platforms: ["linux"]
url: "https://new.carta.tech/ACE_POSIX_Asynch_Result"
---

# ACE\_POSIX\_Asynch\_Result(3)

This class provides concrete implementation for ACE\_Asynch\_Result for POSIX4 platforms. This class extends aiocb and makes it more useful.

## NAME

ACE\_POSIX\_Asynch\_Result -

This class provides concrete implementation for ACE\_Asynch\_Result for POSIX4 platforms. This class extends aiocb and makes it more useful.

## SYNOPSIS

```
class ACE_POSIX_Asynch_Result :
  public virtual ACE_Asynch_Result_Impl,
  public aiocb
{
  public:
    u_long bytes_transferred (void) const;
    const void *act (void) const;
    int success (void) const;
    const void *completion_key (void) const;
    u_long error (void) const;
    ACE_HANDLE event (void) const;
    u_long offset (void) const;
    u_long offset_high (void) const;
    int priority (void) const;
    int signal_number (void) const;
    int post_completion (ACE_Proactor_Impl *proactor);
    virtual ~ACE_POSIX_Asynch_Result (void);
  protected:
    ACE_POSIX_Asynch_Result (
        ACE_Handler &handler,
        const void* act,
        ACE_HANDLE event,
        u_long offset,
        u_long offset_high,
        int priority,
        int signal_number
        );
    ACE_Handler &handler_;
    const void *act_;
    u_long bytes_transferred_;
    int success_;
    const void *completion_key_;
    u_long error_;
};
```

## DESCRIPTION

The implementation classes for POSIX implementation of Asynch Operations are defined here in this file.

## PUBLIC MEMBERS

```
u_long 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;
```

This is the ACT associated with the handle on which the Asynch\_Operation takes place.

@@ This is not implemented for POSIX4 platforms.

```
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;
```

This really make sense only when doing file I/O.

@@ On POSIX4-Unix, offset\_high should be supported using\
     aiocb64.

```
int priority (void) const;
```

Priority of the operation.

```
int signal_number (void) const;
```

POSIX4 real-time signal number to be used for the operation. signal\_number ranges from SIGRTMIN to SIGRTMAX. By  default, SIGRTMIN is used to issue aio\_ calls.

```
int post_completion (ACE_Proactor_Impl *proactor);
```

Post this to the Proactor.

```
virtual ~ACE_POSIX_Asynch_Result (void);
```

Destructor.

## PROTECTED MEMBERS

```
ACE_POSIX_Asynch_Result (
    ACE_Handler &handler,
    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.

```
ACE_Handler &handler_;
```

Handler that will be called back.

```
const void *act_;
```

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.

```
u_long 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.

## AUTHOR

Irfan Pyarali (irfan@cs.wustl.edu), Tim Harrison (harrison@cs.wustl.edu) and Alexander Babu Arulanthu alex@cs.wustl.edu

## LIBRARY

ace