NAME
ACE_Asynch_Transmit_File -
This class is a factory for starting off asynchronous transmit files on a stream.
SYNOPSIS
class ACE_Asynch_Transmit_File : public ACE_Asynch_Operation
{
public:
ACE_Asynch_Transmit_File (void);
virtual ~ACE_Asynch_Transmit_File (void);
int open (
ACE_Handler &handler,
ACE_HANDLE handle = ACE_INVALID_HANDLE,
const void *completion_key = 0,
ACE_Proactor *proactor = 0
);
int transmit_file (
ACE_HANDLE file,
Header_And_Trailer *header_and_trailer = 0,
u_long bytes_to_write = 0,
u_long offset = 0,
u_long offset_high = 0,
u_long bytes_per_send = 0,
u_long flags = 0,
const void *act = 0,
int priority = 0,
int signal_number = ACE_SIGRTMIN
);
ACE_Asynch_Transmit_File_Impl *implementation (void) const;
class Result : public ACE_Asynch_Result
{
public:
friend class ACE_POSIX_Asynch_Read_Stream_Result;
friend class ACE_WIN32_Asynch_Read_Stream_Result;
u_long bytes_to_read (void) const;
ACE_Message_Block &message_block (void) const;
ACE_HANDLE handle (void) const;
ACE_Asynch_Read_Stream_Result_Impl *implementation (
void
) const;
friend class ACE_POSIX_Asynch_Write_Stream_Result;
friend class ACE_WIN32_Asynch_Write_Stream_Result;
u_long bytes_to_write (void) const;
ACE_Message_Block &message_block (void) const;
ACE_HANDLE handle (void) const;
ACE_Asynch_Write_Stream_Result_Impl *implementation (
void
) const;
friend class ACE_POSIX_Asynch_Read_File_Result;
friend class ACE_WIN32_Asynch_Read_File_Result;
ACE_Asynch_Read_File_Result_Impl *implementation (void) const;
friend class ACE_POSIX_Asynch_Write_File_Result;
friend class ACE_WIN32_Asynch_Write_File_Result;
ACE_Asynch_Write_File_Result_Impl *implementation (
void
) const;
friend class ACE_POSIX_Asynch_Accept_Result;
friend class ACE_WIN32_Asynch_Accept_Result;
u_long bytes_to_read (void) const;
ACE_Message_Block &message_block (void) const;
ACE_HANDLE listen_handle (void) const;
ACE_HANDLE accept_handle (void) const;
ACE_Asynch_Accept_Result_Impl *implementation (void) const;
friend class ACE_POSIX_Asynch_Transmit_File_Result;
friend class ACE_WIN32_Asynch_Transmit_File_Result;
ACE_HANDLE socket (void) const;
ACE_HANDLE file (void) const;
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;
ACE_Asynch_Transmit_File_Result_Impl *implementation (
void
) const;
protected:
Result (ACE_Asynch_Read_Stream_Result_Impl *implementation);
virtual ~Result (void);
ACE_Asynch_Read_Stream_Result_Impl *implementation_;
Result (ACE_Asynch_Write_Stream_Result_Impl *implementation);
virtual ~Result (void);
ACE_Asynch_Write_Stream_Result_Impl *implementation_;
Result (ACE_Asynch_Read_File_Result_Impl *implementation);
virtual ~Result (void);
ACE_Asynch_Read_File_Result_Impl *implementation_;
Result (ACE_Asynch_Write_File_Result_Impl *implementation);
virtual ~Result (void);
ACE_Asynch_Write_File_Result_Impl *implementation_;
Result (ACE_Asynch_Accept_Result_Impl *implementation);
virtual ~Result (void);
ACE_Asynch_Accept_Result_Impl *implementation_;
Result (ACE_Asynch_Transmit_File_Result_Impl *implementation);
virtual ~Result (void);
ACE_Asynch_Transmit_File_Result_Impl *implementation_;
};
protected: void implementation (ACE_Asynch_Transmit_File_Impl *); ACE_Asynch_Transmit_File_Impl *implementation_;
class Header_And_Trailer
{
public: Header_And_Trailer (
ACE_Message_Block *header = 0,
u_long header_bytes = 0,
ACE_Message_Block *trailer = 0,
u_long trailer_bytes = 0
); virtual ~Header_And_Trailer (void); void header_and_trailer (
ACE_Message_Block *header = 0,
u_long header_bytes = 0,
ACE_Message_Block *trailer = 0,
u_long trailer_bytes = 0
); ACE_Message_Block *header (void) const; void header (ACE_Message_Block *message_block); u_long header_bytes (void) const; void header_bytes (u_long bytes); ACE_Message_Block *trailer (void) const; void trailer (ACE_Message_Block *message_block); u_long trailer_bytes (void) const; void trailer_bytes (u_long bytes); ACE_LPTRANSMIT_FILE_BUFFERS transmit_buffers (void);
protected: ACE_Message_Block *header_; u_long header_bytes_; ACE_Message_Block *trailer_; u_long trailer_bytes_; ACE_TRANSMIT_FILE_BUFFERS transmit_buffers_;
}; };
DESCRIPTION
This works on Win32 (#if defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) platforms and on POSIX4 platforms with aio_* routines (#if defined (ACE_HAS_AIO_CALLS))
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
ACE_Asynch_Transmit_File (void);
A do nothing constructor.
virtual ~ACE_Asynch_Transmit_File (void);
Destructor.
int open (
ACE_Handler &handler,
ACE_HANDLE handle = ACE_INVALID_HANDLE,
const void *completion_key = 0,
ACE_Proactor *proactor = 0
);
Initializes the factory with information which will be used with each asynchronous call. If (handle == ACE_INVALID_HANDLE), ACE_Handler::handle will be called on the handler to get the correct handle.
int transmit_file (
ACE_HANDLE file,
Header_And_Trailer *header_and_trailer = 0,
u_long bytes_to_write = 0,
u_long offset = 0,
u_long offset_high = 0,
u_long bytes_per_send = 0,
u_long flags = 0,
const void *act = 0,
int priority = 0,
int signal_number = ACE_SIGRTMIN
);
This starts off an asynchronous transmit file. The file is a handle to an open file. header_and_trailer is a pointer to a data structure that contains pointers to data to send before and after the file data is sent. Set this parameter to 0 if you only want to transmit the file data. Upto bytes_to_write will be written to the socket. If you want to send the entire file, let bytes_to_write = 0. bytes_per_send is the size of each block of data sent per send operation. Please read the Win32 documentation on what the flags should be. Priority of the operation is specified by priority. On POSIX4-Unix, this is supported. Works like nice in Unix. Negative values are not allowed. 0 means priority of the operation same as the process priority. 1 means priority of the operation is one less than process. And so forth. On Win32, this is a no-op. signal_number is the POSIX4 real-time signal number to be used for the operation. signal_number ranges from ACE_SIGRTMIN to ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems.
ACE_Asynch_Transmit_File_Impl *implementation (void) const;
Return the underlying implementation class.
PROTECTED MEMBERS
void implementation (ACE_Asynch_Transmit_File_Impl *);
Set the implementation.
ACE_Asynch_Transmit_File_Impl *implementation_;
The implementation class.
AUTHOR
Irfan Pyarali [email protected], Tim Harrison [email protected] and Alexander Babu Arulanthu [email protected]
LIBRARY
ace