## NAME

ACE_POSIX_Asynch_Write_Stream_Result -

This class provides concrete implementation for ACE_Asynch_Write_Stream::Result on POSIX platforms.

## SYNOPSIS

    class ACE_POSIX_Asynch_Write_Stream_Result :
      public virtual ACE_Asynch_Write_Stream_Result_Impl,
      public ACE_POSIX_Asynch_Result
    {
      public:
        friend class ACE_POSIX_AIOCB_Asynch_Write_Stream;
        friend class ACE_POSIX_SIG_Asynch_Write_Stream;
        friend class ACE_POSIX_Proactor;
        u_long bytes_to_write (void) const;
        ACE_Message_Block &message_block (void) const;
        ACE_HANDLE handle (void) const;
        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);
      protected:
        ACE_POSIX_Asynch_Write_Stream_Result (
            ACE_Handler &handler,
            ACE_HANDLE handle,
            ACE_Message_Block &message_block,
            u_long bytes_to_write,
            const void* act,
            ACE_HANDLE event,
            int priority,
            int signal_number
            );
        virtual void complete (
            u_long bytes_transferred,
            int success,
            const void *completion_key,
            u_long error
            );
        virtual ~ACE_POSIX_Asynch_Write_Stream_Result (void);
        ACE_Message_Block &message_block_;
    };

## DESCRIPTION

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

## Base class operations. These operations are here to kill

dominance warnings. These methods call the base class methods.

    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;

The priority of the asynchronous 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. This is a no-op on non-POSIX4 systems and returns 0.

    int post_completion (ACE_Proactor_Impl *proactor);

Post `this` to the Proactor.

## AUTHOR

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

## LIBRARY

ace