---
name: "ACE_POSIX_Proactor"
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_Proactor"
---

# ACE\_POSIX\_Proactor(3)

POSIX implementation of the Proactor.

## NAME

ACE\_POSIX\_Proactor -

POSIX implementation of the Proactor.

## SYNOPSIS

```
#include <ace/POSIX_Proactor.h>
class ACE_POSIX_Proactor : public ACE_Proactor_Impl
{
  public:
    friend class ACE_POSIX_SIG_Asynch_Accept_Handler;
    virtual ~ACE_POSIX_Proactor (void);
    virtual int close (void);
    virtual int register_handle (
        ACE_HANDLE handle,
        const void *completion_key
        );
    virtual int post_completion (ACE_POSIX_Asynch_Result *result) = 0;
    int wake_up_dispatch_threads (void);
    int close_dispatch_threads (int wait);
    size_t number_of_threads (void) const;
    void number_of_threads (size_t threads);
    virtual ACE_HANDLE get_handle (void) const;
    virtual ACE_Asynch_Read_Stream_Result_Impl *create_asynch_read_stream_result (
        ACE_Handler &handler,
        ACE_HANDLE handle,
        ACE_Message_Block &message_block,
        u_long bytes_to_read,
        const void* act,
        ACE_HANDLE event = ACE_INVALID_HANDLE,
        int priority = 0,
        int signal_number = ACE_SIGRTMIN
        );
    virtual ACE_Asynch_Write_Stream_Result_Impl *create_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 = ACE_INVALID_HANDLE,
        int priority = 0,
        int signal_number = ACE_SIGRTMIN
        );
    virtual ACE_Asynch_Read_File_Result_Impl *create_asynch_read_file_result (
        ACE_Handler &handler,
        ACE_HANDLE handle,
        ACE_Message_Block &message_block,
        u_long bytes_to_read,
        const void* act,
        u_long offset,
        u_long offset_high,
        ACE_HANDLE event = ACE_INVALID_HANDLE,
        int priority = 0,
        int signal_number = ACE_SIGRTMIN
        );
    virtual ACE_Asynch_Write_File_Result_Impl *create_asynch_write_file_result (
        ACE_Handler &handler,
        ACE_HANDLE handle,
        ACE_Message_Block &message_block,
        u_long bytes_to_write,
        const void* act,
        u_long offset,
        u_long offset_high,
        ACE_HANDLE event = ACE_INVALID_HANDLE,
        int priority = 0,
        int signal_number = ACE_SIGRTMIN
        );
    virtual ACE_Asynch_Accept_Result_Impl *create_asynch_accept_result (
        ACE_Handler &handler,
        ACE_HANDLE listen_handle,
        ACE_HANDLE accept_handle,
        ACE_Message_Block &message_block,
        u_long bytes_to_read,
        const void* act,
        ACE_HANDLE event = ACE_INVALID_HANDLE,
        int priority = 0,
        int signal_number = ACE_SIGRTMIN
        );
    virtual ACE_Asynch_Transmit_File_Result_Impl *create_asynch_transmit_file_result (
        ACE_Handler &handler,
        ACE_HANDLE socket,
        ACE_HANDLE file,
        ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
        u_long bytes_to_write,
        u_long offset,
        u_long offset_high,
        u_long bytes_per_send,
        u_long flags,
        const void *act,
        ACE_HANDLE event = ACE_INVALID_HANDLE,
        int priority = 0,
        int signal_number = ACE_SIGRTMIN
        );
    virtual ACE_Asynch_Result_Impl *create_asynch_timer (
        ACE_Handler &handler,
        const void *act,
        const ACE_Time_Value &tv,
        ACE_HANDLE event = ACE_INVALID_HANDLE,
        int priority = 0,
        int signal_number = ACE_SIGRTMIN
        );
  protected:
    ACE_POSIX_Proactor (void);
    void application_specific_code (
        ACE_POSIX_Asynch_Result *asynch_result,
        u_long bytes_transferred,
        int success,
        const void *completion_key,
        u_long error
        );
    virtual int post_wakeup_completions (int how_many);
    ACE_Handler wakeup_handler_;
};
```

## DESCRIPTION

There are two different strategies by which Proactor can get to know the completion of aio operations. One is based on Asynchronous I/O Control Blocks (AIOCB) where a list of AIOCBs are stored and completion status of the corresponding operations are queried on them. The other one is based on POSIX Real Time signals. This class abstracts out the common code needed for both the strategies. ACE\_AIOCB\_Proactor and ACE\_SIG\_Proactor specialize this class for each strategy.

## PUBLIC MEMBERS

```
friend class ACE_POSIX_SIG_Asynch_Accept_Handler;
```

For POSIX\_SIG\_Asynch\_Accept operation, this handler class does the actual work, has to register the real-time signal with the Proactor.

```
virtual ~ACE_POSIX_Proactor (void);
```

Virtual destructor.

```
virtual int close (void);
```

Close down the Proactor.

```
virtual int register_handle (
    ACE_HANDLE handle,
    const void *completion_key
    );
```

This function is a no-op function for Unix systems. Returns 0.

```
virtual int post_completion (ACE_POSIX_Asynch_Result *result) = 0;
```

Post a result to the completion port of the Proactor.  If errors occur, the result will be deleted by this method.  If successful, the result will be deleted by the Proactor when the result is removed from the completion port. Therefore, the result should have been dynamically allocated and should be orphaned by the user once this method is called.

```
int wake_up_dispatch_threads (void);
```

@@ This is a no-op on POSIX platforms. Returns 0.

```
int close_dispatch_threads (int wait);
```

@@ This is a no-op on POSIX platforms. Returns 0.

```
size_t number_of_threads (void) const;
```

```
void number_of_threads (size_t threads);
```

@@ This is a no-op on POSIX platforms. Returns 0.

```
virtual ACE_HANDLE get_handle (void) const;
```

This is a no-op in POSIX. Returns ACE\_INVALID\_HANDLE.

```
virtual ACE_Asynch_Read_Stream_Result_Impl *create_asynch_read_stream_result (
    ACE_Handler &handler,
    ACE_HANDLE handle,
    ACE_Message_Block &message_block,
    u_long bytes_to_read,
    const void* act,
    ACE_HANDLE event = ACE_INVALID_HANDLE,
    int priority = 0,
    int signal_number = ACE_SIGRTMIN
    );
```

```
virtual ACE_Asynch_Write_Stream_Result_Impl *create_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 = ACE_INVALID_HANDLE,
    int priority = 0,
    int signal_number = ACE_SIGRTMIN
    );
```

```
virtual ACE_Asynch_Read_File_Result_Impl *create_asynch_read_file_result (
    ACE_Handler &handler,
    ACE_HANDLE handle,
    ACE_Message_Block &message_block,
    u_long bytes_to_read,
    const void* act,
    u_long offset,
    u_long offset_high,
    ACE_HANDLE event = ACE_INVALID_HANDLE,
    int priority = 0,
    int signal_number = ACE_SIGRTMIN
    );
```

```
virtual ACE_Asynch_Write_File_Result_Impl *create_asynch_write_file_result (
    ACE_Handler &handler,
    ACE_HANDLE handle,
    ACE_Message_Block &message_block,
    u_long bytes_to_write,
    const void* act,
    u_long offset,
    u_long offset_high,
    ACE_HANDLE event = ACE_INVALID_HANDLE,
    int priority = 0,
    int signal_number = ACE_SIGRTMIN
    );
```

```
virtual ACE_Asynch_Accept_Result_Impl *create_asynch_accept_result (
    ACE_Handler &handler,
    ACE_HANDLE listen_handle,
    ACE_HANDLE accept_handle,
    ACE_Message_Block &message_block,
    u_long bytes_to_read,
    const void* act,
    ACE_HANDLE event = ACE_INVALID_HANDLE,
    int priority = 0,
    int signal_number = ACE_SIGRTMIN
    );
```

```
virtual ACE_Asynch_Transmit_File_Result_Impl *create_asynch_transmit_file_result (
    ACE_Handler &handler,
    ACE_HANDLE socket,
    ACE_HANDLE file,
    ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
    u_long bytes_to_write,
    u_long offset,
    u_long offset_high,
    u_long bytes_per_send,
    u_long flags,
    const void *act,
    ACE_HANDLE event = ACE_INVALID_HANDLE,
    int priority = 0,
    int signal_number = ACE_SIGRTMIN
    );
```

```
virtual ACE_Asynch_Result_Impl *create_asynch_timer (
    ACE_Handler &handler,
    const void *act,
    const ACE_Time_Value &tv,
    ACE_HANDLE event = ACE_INVALID_HANDLE,
    int priority = 0,
    int signal_number = ACE_SIGRTMIN
    );
```

Create a timer result object which can be used with the Timer mechanism of the Proactor.

## PROTECTED MEMBERS

```
ACE_POSIX_Proactor (void);
```

Constructor.

```
void application_specific_code (
    ACE_POSIX_Asynch_Result *asynch_result,
    u_long bytes_transferred,
    int success,
    const void *completion_key,
    u_long error
    );
```

Protect against structured exceptions caused by user code when dispatching handles. The completion\_key is not very useful compared to AST that can be associated each asynchronous operation. completion\_key is implemented right now for the POSIX Proators.

```
virtual int post_wakeup_completions (int how_many);
```

Post how\_many completions to the completion port so that all threads can wake up. This is used in conjunction with the run\_event\_loop.

```
ACE_Handler wakeup_handler_;
```

Handler to handle the wakeups. This works in conjunction with the ACE\_Proactor::run\_event\_loop.

## AUTHOR

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

## LIBRARY

ace