## 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