diff options
Diffstat (limited to 'ace/Asynch_IO.h')
-rw-r--r-- | ace/Asynch_IO.h | 1108 |
1 files changed, 0 insertions, 1108 deletions
diff --git a/ace/Asynch_IO.h b/ace/Asynch_IO.h deleted file mode 100644 index 344563e6aa0..00000000000 --- a/ace/Asynch_IO.h +++ /dev/null @@ -1,1108 +0,0 @@ -/* -*- C++ -*- */ -// $Id$ - -// ============================================================================ -// -// = LIBRARY -// ace -// = FILENAME -// Asynch_IO.h -// -// = 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. -// -// = AUTHOR -// Irfan Pyarali <irfan@cs.wustl.edu>, -// Tim Harrison <harrison@cs.wustl.edu> and -// Alexander Babu Arulanthu <alex@cs.wustl.edu> -// -// ============================================================================ - -#ifndef ACE_ASYNCH_IO_H -#define ACE_ASYNCH_IO_H -#include "ace/pre.h" - -#include "ace/OS.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)) - -// Forward declarations -class ACE_Proactor; -class ACE_Handler; -class ACE_Message_Block; -class ACE_INET_Addr; - -// Forward declarations -class ACE_Asynch_Result_Impl; - -class ACE_Export ACE_Asynch_Result -{ - // = TITLE - // - // An interface base class which allows users access to common - // information related to an asynchronous operation. - // - // = DESCRIPTION - // - // An interface base class from which you can obtain some basic - // information like the number of bytes transferred, the ACT - // associated with the asynchronous operation, indication of - // success or failure, etc. Subclasses may want to store more - // information that is particular to the asynchronous operation - // it represents. - -public: - 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. - // - // On WIN32, this returns the ACT associated with the handle when it - // was registered with the I/O completion port. - // - // @@ This is not implemented for POSIX4 platforms. Returns 0. - - u_long error (void) const; - // Error value if the operation fails. - - ACE_HANDLE event (void) const; - // On WIN32, this returns the event associated with the OVERLAPPED - // structure. - // - // This returns ACE_INVALID_HANDLE on POSIX4-Unix platforms. - - u_long offset (void) const; - u_long offset_high (void) const; - // This really makes sense only when doing file I/O. - // - // On WIN32, these are represented in the OVERLAPPED datastructure. - // - // @@ On POSIX4-Unix, offset_high should be supported using - // aiocb64. - - int priority (void) const; - // Priority of the operation. - // - // On POSIX4-Unix, this is supported. Priority 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. - - int signal_number (void) const; - // POSIX4 real-time signal number to be used for the - // operation. <signal_number> ranges from ACE_SIGRTMIN to ACE_SIGRTMAX. By - // default, ACE_SIGRTMIN is used to issue <aio_> calls. This is a no-op - // on non-POSIX4 systems and returns 0. - - - virtual ~ACE_Asynch_Result (void); - // Destructor. - -protected: - ACE_Asynch_Result (ACE_Asynch_Result_Impl *implementation); - // Constructor. This implementation will not be deleted. The - // implementation will be deleted by the Proactor. - - ACE_Asynch_Result_Impl *implementation (void) const; - // Get the implementation class. - - ACE_Asynch_Result_Impl *implementation_; - // Implementation class. -}; - -// Forward declarations -class ACE_Asynch_Operation_Impl; - -class ACE_Export ACE_Asynch_Operation -{ - // = TITLE - // - // This is an interface base class for all asynch - // operations. The resposiblility of this class is to forward - // all methods to its delegation/implementation class, e.g., - // <ACE_WIN32_Asynch_Operation> or <ACE_POSIX_Asynch_Operation>. - // - // = DESCRIPTION - // - // There are some attributes and functionality which is common - // to all asychronous operations. The delegation classes of this - // class will factor out this code. - -public: - int open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor); - // 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 cancel (void); - // (Attempts to) cancel the asynchronous operation pending against - // the <handle> registered with this Operation. - // - // All completion notifications for the I/O operations will occur - // normally. - // - // = Return Values: - // - // -1 : Operation failed. (can get only in POSIX). - // 0 : All the operations were cancelled. - // 1 : All the operations were already finished in this - // handle. Unable to cancel them. - // 2 : Atleast one of the requested operations cannot be - // cancelled. - // - // There is slight difference in the semantics between NT and POSIX - // platforms which is given below. - // - // = Win32 : - // - // cancels all pending accepts operations that were issued by the - // calling thread. The function does not cancel asynchronous - // operations issued by other threads. - // All I/O operations that are canceled will complete with the - // error ERROR_OPERATION_ABORTED. - // - // = POSIX: - // - // Attempts to cancel one or more asynchronous I/O requests - // currently outstanding against the <handle> registered in this - // operation. - // For requested operations that are successfully canceled, the - // associated error status is set to ECANCELED. - - - // = Access methods. - - ACE_Proactor* proactor (void) const; - // Return the underlying proactor. - - virtual ~ACE_Asynch_Operation (void); - // Destructor. - -protected: - ACE_Asynch_Operation (void); - // Constructor. - - ACE_Asynch_Operation_Impl *implementation (void) const; - // Return the underlying implementation class. - - void implementation (ACE_Asynch_Operation_Impl *implementation); - // Set the implementation class. - - ACE_Proactor *get_proactor (ACE_Proactor *user_proactor, - ACE_Handler &handler) const; - // Get a proactor for/from the user - - ACE_Asynch_Operation_Impl *implementation_; - // Implementation class. -}; - -// Forward declarations -class ACE_Asynch_Read_Stream_Result_Impl; -class ACE_Asynch_Read_Stream_Impl; - -class ACE_Export ACE_Asynch_Read_Stream : public ACE_Asynch_Operation -{ - // = TITLE - // - // This class is a factory for starting off asynchronous reads - // on a stream. This class forwards all methods to its - // implementation class. - // - // = DESCRIPTION - // - // Once <open> is called, multiple asynchronous <read>s can - // started using this class. An ACE_Asynch_Read_Stream::Result - // will be passed back to the <handler> when the asynchronous - // reads completes through the <ACE_Handler::handle_read_stream> - // callback. - -public: - ACE_Asynch_Read_Stream (void); - // A do nothing constructor. - - virtual ~ACE_Asynch_Read_Stream (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 read (ACE_Message_Block &message_block, - u_long bytes_to_read, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - // This starts off an asynchronous read. Upto <bytes_to_read> will - // be read and stored in the <message_block>. <message_block>'s - // <wr_ptr> will be updated to reflect the added bytes if the read - // operation is successful completed. 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, <priority> 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_Read_Stream_Impl *implementation (void) const; - // Return the underlying implementation class. - -protected: - void implementation (ACE_Asynch_Read_Stream_Impl *implementation); - // Set the implementation class. - - ACE_Asynch_Read_Stream_Impl *implementation_; - // Implementation class that all methods will be forwarded to. - -public: - class ACE_Export Result : public ACE_Asynch_Result - { - // = TITLE - // - // This is the class which will be passed back to the - // <handler> when the asynchronous read completes. This class - // forwards all the methods to the implementation classes. - // - // = DESCRIPTION - // - // This class has all the information necessary for the - // <handler> to uniquiely identify the completion of the - // asynchronous read. - - friend class ACE_POSIX_Asynch_Read_Stream_Result; - friend class ACE_WIN32_Asynch_Read_Stream_Result; - // The concrete implementation result classes only construct this - // class. - - public: - u_long bytes_to_read (void) const; - // The number of bytes which were requested at the start of the - // asynchronous read. - - ACE_Message_Block &message_block (void) const; - // Message block which contains the read data. - - ACE_HANDLE handle (void) const; - // I/O handle used for reading. - - ACE_Asynch_Read_Stream_Result_Impl *implementation (void) const; - // Get the implementation class. - - protected: - Result (ACE_Asynch_Read_Stream_Result_Impl *implementation); - // Constructor. - - virtual ~Result (void); - // Destructor. - - ACE_Asynch_Read_Stream_Result_Impl *implementation_; - // The implementation class. - }; -}; - -// Forward declarations -class ACE_Asynch_Write_Stream_Impl; -class ACE_Asynch_Write_Stream_Result_Impl; - -class ACE_Export ACE_Asynch_Write_Stream : public ACE_Asynch_Operation -{ - // = TITLE - // - // This class is a factory for starting off asynchronous writes - // on a stream. This class forwards all methods to its - // implementation class. - // - // = DESCRIPTION - // - // Once <open> is called, multiple asynchronous <writes>s can - // started using this class. An ACE_Asynch_Write_Stream::Result - // will be passed back to the <handler> when the asynchronous - // write completes through the - // <ACE_Handler::handle_write_stream> callback. - -public: - ACE_Asynch_Write_Stream (void); - // A do nothing constructor. - - virtual ~ACE_Asynch_Write_Stream (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 write (ACE_Message_Block &message_block, - u_long bytes_to_write, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - // This starts off an asynchronous write. Upto <bytes_to_write> - // will be written from the <message_block>. Upon successful completion - // of the write operation, <message_block>'s <rd_ptr> is updated to - // reflect the data that was written. 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 argument 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_Write_Stream_Impl *implementation (void) const; - // Return the underlying implementation class. - -protected: - void implementation (ACE_Asynch_Write_Stream_Impl *implementation); - // Set the implementation class. - - ACE_Asynch_Write_Stream_Impl *implementation_; - // Implementation class that all methods will be forwarded to. - -public: - class ACE_Export Result : public ACE_Asynch_Result - { - // = TITLE - // - // This is that class which will be passed back to the - // <handler> when the asynchronous write completes. This class - // forwards all the methods to the implementation class. - // - // = DESCRIPTION - // - // This class has all the information necessary for the - // <handler> to uniquiely identify the completion of the - // asynchronous write. - - friend class ACE_POSIX_Asynch_Write_Stream_Result; - friend class ACE_WIN32_Asynch_Write_Stream_Result; - // The concrete implementation result classes only construct this - // class. - - public: - u_long bytes_to_write (void) const; - // The number of bytes which were requested at the start of the - // asynchronous write. - - ACE_Message_Block &message_block (void) const; - // Message block that contains the data to be written. - - ACE_HANDLE handle (void) const; - // I/O handle used for writing. - - ACE_Asynch_Write_Stream_Result_Impl *implementation (void) const; - // Get the implementation class. - - protected: - Result (ACE_Asynch_Write_Stream_Result_Impl *implementation); - // Constrcutor. - - virtual ~Result (void); - // Destructor. - - ACE_Asynch_Write_Stream_Result_Impl *implementation_; - // Implementation class. - }; -}; - -// Forward declarations -class ACE_Asynch_Read_File_Impl; -class ACE_Asynch_Read_File_Result_Impl; - -class ACE_Export ACE_Asynch_Read_File : public ACE_Asynch_Read_Stream -{ - // = TITLE - // - // This class is a factory for starting off asynchronous reads - // on a file. This class forwards all methods to its - // implementation class. - // - // = DESCRIPTION - // - // Once <open> is called, multiple asynchronous <read>s can - // started using this class. An ACE_Asynch_Read_File::Result - // will be passed back to the <handler> when the asynchronous - // reads completes through the <ACE_Handler::handle_read_file> - // callback. - // - // This class differs slightly from ACE_Asynch_Read_Stream as it - // allows the user to specify an offset for the read. - -public: - ACE_Asynch_Read_File (void); - // A do nothing constructor. - - virtual ~ACE_Asynch_Read_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 read (ACE_Message_Block &message_block, - u_long bytes_to_read, - u_long offset = 0, - u_long offset_high = 0, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - // This starts off an asynchronous read. Upto <bytes_to_read> will - // be read and stored in the <message_block>. The read will start - // at <offset> from the beginning of the file. 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 argument 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_Read_File_Impl *implementation (void) const; - // Return the underlying implementation class. - -protected: - void implementation (ACE_Asynch_Read_File_Impl *implementation); - // Set the implementation class. - - ACE_Asynch_Read_File_Impl *implementation_; - // Delegation/implementation class that all methods will be - // forwarded to. - -public: - class ACE_Export Result : public ACE_Asynch_Read_Stream::Result - { - // = TITLE - // - // This is that class which will be passed back to the - // <handler> when the asynchronous read completes. This class - // forwards all the methods to the implementation class. - // - // = DESCRIPTION - // - // This class has all the information necessary for the - // <handler> to uniquiely identify the completion of the - // asynchronous read. - // - // This class differs slightly from - // ACE_Asynch_Read_Stream::Result as it calls back - // <ACE_Handler::handle_read_file> on the <handler> instead of - // <ACE_Handler::handle_read_stream>. No additional state is - // required by this class as ACE_Asynch_Result can store the - // <offset>. - - friend class ACE_POSIX_Asynch_Read_File_Result; - friend class ACE_WIN32_Asynch_Read_File_Result; - // The concrete implementation result classes only construct this - // class. - - public: - ACE_Asynch_Read_File_Result_Impl *implementation (void) const; - // Get the implementation class. - - protected: - Result (ACE_Asynch_Read_File_Result_Impl *implementation); - // Constructor. This implementation will not be deleted. - - virtual ~Result (void); - // Destructor. - - ACE_Asynch_Read_File_Result_Impl *implementation_; - // The implementation class. - }; -}; - -// Forward declarations -class ACE_Asynch_Write_File_Impl; -class ACE_Asynch_Write_File_Result_Impl; - -class ACE_Export ACE_Asynch_Write_File : public ACE_Asynch_Write_Stream -{ - // = TITLE - // - // This class is a factory for starting off asynchronous writes - // on a file. This class forwards all methods to its - // implementation class. - // - // = DESCRIPTION - // - // Once <open> is called, multiple asynchronous <write>s can be - // started using this class. A ACE_Asynch_Write_File::Result - // will be passed back to the <handler> when the asynchronous - // writes completes through the <ACE_Handler::handle_write_file> - // callback. - // - // This class differs slightly from ACE_Asynch_Write_Stream as - // it allows the user to specify an offset for the write. - -public: - ACE_Asynch_Write_File (void); - // A do nothing constructor. - - virtual ~ACE_Asynch_Write_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 write (ACE_Message_Block &message_block, - u_long bytes_to_write, - u_long offset = 0, - u_long offset_high = 0, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - // This starts off an asynchronous write. Upto <bytes_to_write> - // will be write and stored in the <message_block>. The write will - // start at <offset> from the beginning of the file. 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_Write_File_Impl *implementation (void) const; - // Return the underlying implementation class. - -protected: - void implementation (ACE_Asynch_Write_File_Impl *implementation); - // Set the implementation. - - ACE_Asynch_Write_File_Impl *implementation_; - // Implementation object. - -public: - class ACE_Export Result : public ACE_Asynch_Write_Stream::Result - { - // = TITLE - // - // This is that class which will be passed back to the - // <handler> when the asynchronous write completes. This class - // forwards all the methods to the implementation class. - // - // = DESCRIPTION - // - // This class has all the information necessary for the - // <handler> to uniquiely identify the completion of the - // asynchronous write. - // - // This class differs slightly from - // ACE_Asynch_Write_Stream::Result as it calls back - // <ACE_Handler::handle_write_file> on the <handler> instead - // of <ACE_Handler::handle_write_stream>. No additional state - // is required by this class as ACE_Asynch_Result can store - // the <offset>. - - friend class ACE_POSIX_Asynch_Write_File_Result; - friend class ACE_WIN32_Asynch_Write_File_Result; - // The concrete implementation result classes only construct this - // class. - - public: - ACE_Asynch_Write_File_Result_Impl *implementation (void) const; - // Get the implementation class. - - protected: - Result (ACE_Asynch_Write_File_Result_Impl *implementation); - // Constructor. This implementation will not be deleted. - - virtual ~Result (void); - // Destructor. - - ACE_Asynch_Write_File_Result_Impl *implementation_; - // The implementation class. - }; -}; - -// Forward declarations -class ACE_Asynch_Accept_Result_Impl; -class ACE_Asynch_Accept_Impl; - -class ACE_Export ACE_Asynch_Accept : public ACE_Asynch_Operation -{ - // = TITLE - // - // This class is a factory for starting off asynchronous accepts - // on a listen handle. This class forwards all methods to its - // implementation class. - // - // = DESCRIPTION - // - // Once <open> is called, multiple asynchronous <accept>s can - // started using this class. A ACE_Asynch_Accept::Result will - // be passed back to the <handler> when the asynchronous accept - // completes through the <ACE_Handler::handle_accept> - // callback. - -public: - ACE_Asynch_Accept (void); - // A do nothing constructor. - - virtual ~ACE_Asynch_Accept (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 accept (ACE_Message_Block &message_block, - u_long bytes_to_read, - ACE_HANDLE accept_handle = ACE_INVALID_HANDLE, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - // This starts off an asynchronous accept. The asynchronous accept - // call also allows any initial data to be returned to the - // <handler>. Upto <bytes_to_read> will be read and stored in the - // <message_block>. The <accept_handle> will be used for the - // <accept> call. If (<accept_handle> == INVALID_HANDLE), a new - // handle will be created. 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. - // - // <message_block> must be specified. This is because the address of - // the new connection is placed at the end of this buffer. - // <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_Accept_Impl *implementation (void) const; - // Return the underlying implementation class. - -protected: - void implementation (ACE_Asynch_Accept_Impl *implementation); - // Set the implementation class. - - ACE_Asynch_Accept_Impl *implementation_; - // Delegation/implementation class that all methods will be - // forwarded to. - -public: - class ACE_Export Result : public ACE_Asynch_Result - { - // = TITLE - // - // This is that class which will be passed back to the - // <handler> when the asynchronous accept completes. - // - // = DESCRIPTION - // - // This class has all the information necessary for the - // <handler> to uniquiely identify the completion of the - // asynchronous accept. - - friend class ACE_POSIX_Asynch_Accept_Result; - friend class ACE_WIN32_Asynch_Accept_Result; - // The concrete implementation result classes only construct this - // class. - - public: - u_long bytes_to_read (void) const; - // The number of bytes which were requested at the start of the - // asynchronous accept. - - ACE_Message_Block &message_block (void) const; - // Message block which contains the read data. - - ACE_HANDLE listen_handle (void) const; - // I/O handle used for accepting new connections. - - ACE_HANDLE accept_handle (void) const; - // I/O handle for the new connection. - - ACE_Asynch_Accept_Result_Impl *implementation (void) const; - // Get the implementation. - - protected: - Result (ACE_Asynch_Accept_Result_Impl *implementation); - // Contructor. Implementation will not be deleted. - - virtual ~Result (void); - // Destructor. - - ACE_Asynch_Accept_Result_Impl *implementation_; - // Impelmentation class. - }; -}; - -// Forward declarations -class ACE_Asynch_Transmit_File_Result_Impl; -class ACE_Asynch_Transmit_File_Impl; - -class ACE_Export ACE_Asynch_Transmit_File : public ACE_Asynch_Operation -{ - // = TITLE - // - // This class is a factory for starting off asynchronous - // transmit files on a stream. - // - // = DESCRIPTION - // - // Once <open> is called, multiple asynchronous <transmit_file>s - // can started using this class. A - // ACE_Asynch_Transmit_File::Result will be passed back to the - // <handler> when the asynchronous transmit file completes - // through the <ACE_Handler::handle_transmit_file> callback. - // - // The transmit_file function transmits file data over a - // connected network connection. The function uses the operating - // system's cache manager to retrieve the file data. This - // function provides high-performance file data transfer over - // network connections. This function would be of great use in - // a Web Server, Image Server, etc. - -public: - // Forward declarations - class Header_And_Trailer; - - 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: - void implementation (ACE_Asynch_Transmit_File_Impl *); - // Set the implementation. - - ACE_Asynch_Transmit_File_Impl *implementation_; - // The implementation class. - -public: - class ACE_Export Result : public ACE_Asynch_Result - { - // = TITLE - // - // This is that class which will be passed back to the - // <handler> when the asynchronous transmit file completes. - // - // = DESCRIPTION - // - // This class has all the information necessary for the - // <handler> to uniquiely identify the completion of the - // asynchronous transmit file. - - friend class ACE_POSIX_Asynch_Transmit_File_Result; - friend class ACE_WIN32_Asynch_Transmit_File_Result; - // The concrete implementation result classes only construct this - // class. - - public: - ACE_HANDLE socket (void) const; - // Socket used for transmitting the file. - - ACE_HANDLE file (void) const; - // File from which the data is read. - - 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. - - ACE_Asynch_Transmit_File_Result_Impl *implementation (void) const; - // Get the implementation class. - - protected: - Result (ACE_Asynch_Transmit_File_Result_Impl *implementation); - // Constructor. - - virtual ~Result (void); - // Destructor. - - ACE_Asynch_Transmit_File_Result_Impl *implementation_; - // The implementation class. - }; - - class ACE_Export Header_And_Trailer - { - // = TITLE - // - // The class defines a data structure that contains pointers - // to data to send before and after the file data is sent. - // - // = DESCRIPTION - // - // This class provides a wrapper over TRANSMIT_FILE_BUFFERS - // and provided a consistent use of ACE_Message_Blocks. - - public: - Header_And_Trailer (ACE_Message_Block *header = 0, - u_long header_bytes = 0, - ACE_Message_Block *trailer = 0, - u_long trailer_bytes = 0); - // Constructor. - - virtual ~Header_And_Trailer (void); - // Destructor - - void header_and_trailer (ACE_Message_Block *header = 0, - u_long header_bytes = 0, - ACE_Message_Block *trailer = 0, - u_long trailer_bytes = 0); - // This method allows all the member to be set in one fell swoop. - - ACE_Message_Block *header (void) const; - void header (ACE_Message_Block *message_block); - // Header which goes before the file data. - - u_long header_bytes (void) const; - void header_bytes (u_long bytes); - // Size of the header data. - - ACE_Message_Block *trailer (void) const; - void trailer (ACE_Message_Block *message_block); - // Trailer which goes after the file data. - - u_long trailer_bytes (void) const; - void trailer_bytes (u_long bytes); - // Size of the trailer data. - - ACE_LPTRANSMIT_FILE_BUFFERS transmit_buffers (void); - // Conversion routine. - - protected: - ACE_Message_Block *header_; - // Header data. - - u_long header_bytes_; - // Size of header data. - - ACE_Message_Block *trailer_; - // Trailer data. - - u_long trailer_bytes_; - // Size of trailer data. - - ACE_TRANSMIT_FILE_BUFFERS transmit_buffers_; - // Target data structure. - }; -}; - -class ACE_Export ACE_Handler -{ - // = TITLE - // This base class defines the interface for receiving the - // results of asynchronous operations. - // - // = DESCRIPTION - // Subclasses of this class will fill in appropriate methods. -public: - ACE_Handler (void); - // A do nothing constructor. - - ACE_Handler (ACE_Proactor *p); - // A do nothing constructor which allows proactor to be set to <p>. - - virtual ~ACE_Handler (void); - // Virtual destruction. - - virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result); - // This method will be called when an asynchronous read completes on - // a stream. - - virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result); - // This method will be called when an asynchronous write completes - // on a stream. - - virtual void handle_read_file (const ACE_Asynch_Read_File::Result &result); - // This method will be called when an asynchronous read completes on - // a file. - - virtual void handle_write_file (const ACE_Asynch_Write_File::Result &result); - // This method will be called when an asynchronous write completes - // on a file. - - virtual void handle_accept (const ACE_Asynch_Accept::Result &result); - // This method will be called when an asynchronous accept completes. - - virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result); - // This method will be called when an asynchronous transmit file - // completes. - - virtual void handle_time_out (const ACE_Time_Value &tv, - const void *act = 0); - // Called when timer expires. <tv> was the requested time value and - // <act> is the ACT passed when scheduling the timer. - - virtual void handle_wakeup (void); - // This is method works with the <run_event_loop> of the - // ACE_Proactor. A special <Wake_Up_Completion> is used to wake up - // all the threads that are blocking for completions. - - ACE_Proactor *proactor (void); - // Get the proactor associated with this handler. - - void proactor (ACE_Proactor *p); - // Set the proactor. - - virtual ACE_HANDLE handle (void) const; - // Get the I/O handle used by this <handler>. This method will be - // called by the ACE_Asynch_* classes when an ACE_INVALID_HANDLE is - // passed to <open>. - -protected: - ACE_Proactor *proactor_; - // The proactor associated with this handler. -}; - -// Forward declarations -class ACE_INET_Addr; - -// Forward declarations -template <class HANDLER> -class ACE_Asynch_Acceptor; - -class ACE_Export ACE_Service_Handler : public ACE_Handler -{ - // = TITLE - // - // This base class defines the interface for the - // ACE_Asynch_Acceptor to call into when new connection are - // accepted. - // - // = DESCRIPTION - // - // Subclasses of this class will fill in appropriate methods to - // define application specific behavior. - - friend class ACE_Asynch_Acceptor<ACE_Service_Handler>; - // The Acceptor is the factory and therefore should have special - // privileges. - -public: - ACE_Service_Handler (void); - // A do nothing constructor. - - virtual ~ACE_Service_Handler (void); - // Virtual destruction. - - virtual void open (ACE_HANDLE new_handle, - ACE_Message_Block &message_block); - // <open> is called by ACE_Asynch_Acceptor to initialize a new - // instance of ACE_Service_Handler that has been created after the a - // new connection is accepted. The handle for the new connection is - // passed along with an initial data that may have shown up. - - // protected: - // This should be corrected after the correct semantics of the - // friend has been figured out. - - virtual void addresses (const ACE_INET_Addr &remote_address, - const ACE_INET_Addr &local_address); - // Called by ACE_Asynch_Acceptor to pass the addresses of the new - // connections. - - virtual void act (const void *); - // Called by ACE_Asynch_Acceptor to pass the act. -}; - -#endif /* ACE_WIN32 || ACE_HAS_AIO_CALLS*/ -#include "ace/post.h" -#endif /* ACE_ASYNCH_IO_H */ |