---
name: "ACE_WIN32_Asynch_Transmit_File_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_WIN32_Asynch_Transmit_File_Result"
---

# ACE\_WIN32\_Asynch\_Transmit\_File\_Result(3)

This class implements ACE\_Asynch\_Transmit\_File::Result for WIN32 platforms.

## NAME

ACE\_WIN32\_Asynch\_Transmit\_File\_Result -

This class implements ACE\_Asynch\_Transmit\_File::Result for WIN32 platforms.

## SYNOPSIS

```
class ACE_WIN32_Asynch_Transmit_File_Result :
  public virtual ACE_Asynch_Transmit_File_Result_Impl,
  public ACE_WIN32_Asynch_Result
{
  public:
    friend class ACE_WIN32_Asynch_Transmit_File;
    friend class ACE_WIN32_Proactor;
    ACE_HANDLE socket (void) const;
    ACE_HANDLE file (void) const;
    ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer (
        void
        ) const;
    u_long bytes_to_write (void) const;
    u_long bytes_per_send (void) const;
    u_long flags (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_WIN32_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,
        int priority,
        int signal_number = 0
        );
    virtual void complete (
        u_long bytes_transferred,
        int success,
        const void *completion_key,
        u_long error
        );
    virtual ~ACE_WIN32_Asynch_Transmit_File_Result (void);
    ACE_HANDLE socket_;
    ACE_HANDLE file_;
    ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer_;
    u_long bytes_to_write_;
    u_long bytes_per_send_;
    u_long flags_;
};
```

## DESCRIPTION

These classes only works on Win32 platforms.

The implementation of ACE\_Asynch\_Transmit\_File and ACE\_Asynch\_Accept are only supported if ACE\_HAS\_WINSOCK2 is defined or you are on WinNT 4.0 or higher.

## PUBLIC MEMBERS

```
friend class ACE_WIN32_Asynch_Transmit_File;
```

Factory class will have special permission.

```
friend class ACE_WIN32_Proactor;
```

Proactor class has special permission.

```
ACE_HANDLE socket (void) const;
```

Socket used for transmitting the file.

```
ACE_HANDLE file (void) const;
```

File from which the data is read.

```
ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer (
    void
    ) const;
```

Header and trailer data associated with this transmit file.

```
u_long bytes_to_write (void) const;
```

The number of bytes which were requested at the start of the asynchronous transmit file.

```
u_long bytes_per_send (void) const;
```

Number of bytes per send requested at the start of the transmit file.

```
u_long flags (void) const;
```

Flags which were passed into transmit file.

```
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 returns the ACT associated with the handle when it was registered with the I/O completion port.  This ACT is not the same as the ACT associated with the asynchronous operation.

```
u_long error (void) const;
```

Error value if the operation fail.

```
ACE_HANDLE event (void) const;
```

Event associated with the OVERLAPPED structure.

```
u_long offset (void) const;
```

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

```
u_long offset_high (void) const;
```

Offset\_high associated with the OVERLAPPED structure.

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

The priority of the asynchronous operation. Currently, this is not supported on Win32.

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

No-op. Returns 0.

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

Post this to the Proactor's completion port.

## PROTECTED MEMBERS

```
ACE_WIN32_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,
    int priority,
    int signal_number = 0
    );
```

Constructor is protected since creation is limited to ACE\_Asynch\_Transmit\_File factory.

```
virtual void complete (
    u_long bytes_transferred,
    int success,
    const void *completion_key,
    u_long error
    );
```

Proactor will call this method when the write completes.

```
virtual ~ACE_WIN32_Asynch_Transmit_File_Result (void);
```

Destructor.

```
ACE_HANDLE socket_;
```

Network I/O handle.

```
ACE_HANDLE file_;
```

File I/O handle.

```
ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer_;
```

Header and trailer data associated with this transmit file.

```
u_long bytes_to_write_;
```

The number of bytes which were requested at the start of the asynchronous transmit file.

```
u_long bytes_per_send_;
```

Number of bytes per send requested at the start of the transmit file.

```
u_long flags_;
```

Flags which were passed into transmit file.

## AUTHOR

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

## LIBRARY

ace