This class is a factory for starting off asynchronous transmit files on a stream.
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_;
};
};
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.
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
);
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
);
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;
void implementation (ACE_Asynch_Transmit_File_Impl *);
ACE_Asynch_Transmit_File_Impl *implementation_;
Irfan Pyarali irfan@cs.wustl.edu
,
Tim Harrison harrison@cs.wustl.edu
and
Alexander Babu Arulanthu alex@cs.wustl.edu
ace