diff options
Diffstat (limited to 'ace/Asynch_IO.h')
| -rw-r--r-- | ace/Asynch_IO.h | 873 |
1 files changed, 354 insertions, 519 deletions
diff --git a/ace/Asynch_IO.h b/ace/Asynch_IO.h index fb555a90610..0667f1bdb22 100644 --- a/ace/Asynch_IO.h +++ b/ace/Asynch_IO.h @@ -4,42 +4,40 @@ // ============================================================================ // // = LIBRARY -// // ace // // = FILENAME -// // Asynch_IO.h // // = DESCRIPTION +// This only works on Win32 platforms or on POSIX platforms with +// aio_ routines. // -// 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. +// 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 +// Irfan Pyarali (irfan@cs.wustl.edu), +// Tim Harrison (harrison@cs.wustl.edu) and // Alexander Babu Arulanthu <alex@cs.wustl.edu> // // ============================================================================ -#if !defined (ACE_ASYNCH_IO_H) +#ifndef ACE_ASYNCH_IO_H #define ACE_ASYNCH_IO_H #include "ace/OS.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once +# pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || (defined (ACE_HAS_AIO_CALLS)) +#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) || \ + (defined (ACE_HAS_AIO_CALLS)) + +#include "ace/Task.h" +#include "ace/Reactor.h" // Forward declarations class ACE_Proactor; @@ -47,26 +45,24 @@ class ACE_Handler; class ACE_Message_Block; class ACE_INET_Addr; -// Forward declarations -class ACE_Asynch_Result_Impl; - -class ACE_Export ACE_Asynch_Result +class ACE_Export ACE_Asynch_Result : public ACE_OVERLAPPED { // = TITLE - // - // An interface base class which allows users access to common - // information related to an asynchronous operation. + // An abstract class which adds information to the OVERLAPPED + // structure to make it more useful. // // = DESCRIPTION - // - // An interface base class from which you can obtain some basic + // An abstract 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 + // success or failure, etc. Subclasses may want to store more // information that is particular to the asynchronous operation // it represents. - public: + // Proactor is the only class which is allowed to call the + // <complete> method. + friend class ACE_Proactor; + u_long bytes_transferred (void) const; // Number of bytes transferred by the operation. @@ -77,205 +73,167 @@ public: // 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. + // 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 fails. + // Error value if the operation fail. 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. + // Event associated with the OVERLAPPED structure u_long offset (void) const; u_long offset_high (void) const; - // This really make 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. + // Offset associated with the OVERLAPPED structure. This really + // make sense only when doing file I/O. - int priority (void) const; - // Priority of the operation. - // - // 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. - - 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. + ACE_Asynch_Result (ACE_Handler &handler, + const void* act, + ACE_HANDLE event, + u_long offset = 0, + u_long offset_high = 0); + // Constructor. +#if defined (ACE_HAS_AIO_CALLS) + aiocb* aiocb_ptr (void); + // Returns the underlying <aio control block> used to issue the aio + // call. +#endif /* ACE_HAS_AIO_CALLS */ 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. + virtual void complete (u_long bytes_transferred, + int success, + const void *completion_key, + u_long error = 0) = 0; + // This is the key method. Subclasses will override this method to + // call the correct callback on the handler. + + ACE_Handler &handler_; + // Handler that will be called back. + + const void *act_; + // ACT for this operation. + + u_long bytes_transferred_; + // Bytes transferred by this operation. + + int success_; + // Success indicator. + + const void *completion_key_; + // ACT associated with handle. + + u_long error_; + // Error if operation failed. + +#if defined (ACE_HAS_AIO_CALLS) + aiocb *aiocb_ptr_; + // This is the <aio control block> used to issue the <aio_> + // call. Let us give this to the OS along with the result, so that + // on completion we can take this and use it for <aio_error> and + // <aio_return>. +#endif /* ACE_HAS_AIO_CALLS */ }; -// 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>. + // This is a base class for all asynch operations. // // = 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. - + // to all asychronous operations. This abstract class will + // factor out this code. public: int open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor); + 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 cancel (void); - // On Win32, this cancels all pending accepts operations that were - // issued by the calling thread. The function does not cancel - // asynchronous operations issued by other threads. - // - // @@ POSIX: please implement me. - - // = Access methods. + // This cancels all pending accepts operations that were issued by + // the calling thread. The function does not cancel asynchronous + // operations issued by other threads. - ACE_Proactor* proactor (void) const; + // Access methods. + ACE_Proactor* proactor (void); // Return the underlying proactor. - - virtual ~ACE_Asynch_Operation (void); - // Destructor. - protected: +#if defined (ACE_HAS_AIO_CALLS) + int register_aio_with_proactor (aiocb *aiocb_ptr); + // This call is for the POSIX implementation. This method is used by + // <ACE_Asynch_Operation> to store some information with the + // Proactor after an <aio_> call is issued, so that the Proactor can + // retrive this information to do <aio_return> and <aio_error>. + // Passing a '0' ptr returns the status, indicating whether there + // are slots available or no. Passing a valid ptr stores the ptr + // with the Proactor. +#endif /* ACE_HAS_AIO_CALLS */ + ACE_Asynch_Operation (void); - // Constructor. + // A no-op constructor. - ACE_Asynch_Operation_Impl *implementation (void) const; - // Return the underlying implementation class. + ACE_Proactor *proactor_; + // Proactor that this Asynch IO will be registered with. - 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_Handler *handler_; + // Handler that will receive the callback. - ACE_Asynch_Operation_Impl *implementation_; - // Implementation class. + ACE_HANDLE handle_; + // I/O handle used for reading. }; -// 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. + // on a stream. // // = 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: + class Result; + // Forward declaration of the Result class. + 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); + const void *act = 0); // This starts off an asynchronous read. Upto <bytes_to_read> will - // be read and stored in the <message_block>. 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_Read_Stream_Impl *implementation (void) const; - // Return the underlying implementation class. + // be read and stored in the <message_block>. 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. + int shared_read (Result *result); + // This is the method which does the real work and is there so that + // the ACE_Asynch_Read_File class can use it too. 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. + // This is that class which will be passed back to the + // <handler> when the asynchronous read completes. // // = 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. + friend class ACE_Asynch_Read_Stream; + // The factory has special privileges. public: u_long bytes_to_read (void) const; @@ -288,104 +246,82 @@ public: 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: + // + // These two should really be protected. But sometimes it + // simplifies code to be able to "fake" a result. Use carefully. + Result (ACE_Handler &handler, + ACE_HANDLE handle, + ACE_Message_Block &message_block, + u_long bytes_to_read, + const void* act, + ACE_HANDLE event); + // Constructor is protected since creation is limited to + // ACE_Asynch_Read_Stream factory. + + virtual void complete (u_long bytes_transferred, + int success, + const void *completion_key, + u_long error = 0); + // ACE_Proactor will call this method when the read completes. + protected: - Result (ACE_Asynch_Read_Stream_Result_Impl *implementation); - // Constructor. - - virtual ~Result (void); - // Destructor. + u_long bytes_to_read_; + // Bytes requested when the asynchronous read was initiated. + + ACE_Message_Block &message_block_; + // Message block for reading the data into. - ACE_Asynch_Read_Stream_Result_Impl *implementation_; - // The implementation class. + ACE_HANDLE handle_; + // I/O handle used for reading. }; }; -// 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. + // on a stream. // // = DESCRIPTION - // // Once <open> is called, multiple asynchronous <writes>s can - // started using this class. An ACE_Asynch_Write_Stream::Result + // started using this class. A 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: + class Result; + // Forward declaration of the Result class. + 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); + const void *act = 0); // This starts off an asynchronous write. Upto <bytes_to_write> - // will be written from the <message_block>. 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_Stream_Impl *implementation (void) const; - // Return the underlying implementation class. + // will be written from the <message_block>. 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. + int shared_write (Result *result); + // This is the method which does the real work and is there so that + // the ACE_Asynch_Write_File class can use it too. public: - class ACE_Export Result : public ACE_Asynch_Result + 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. + // <handler> when the asynchronous write completes. // // = 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: + friend class ACE_Asynch_Write_Stream; + // The factory has special privileges. + u_long bytes_to_write (void) const; // The number of bytes which were requested at the start of the // asynchronous write. @@ -396,101 +332,70 @@ public: 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: + // + // These two should really be protected. But sometimes it + // simplifies code to be able to "fake" a result. Use carefully. + Result (ACE_Handler &handler, + ACE_HANDLE handle, + ACE_Message_Block &message_block, + u_long bytes_to_write, + const void* act, + ACE_HANDLE event); + // Constructor is protected since creation is limited to + // ACE_Asynch_Write_Stream factory. + + virtual void complete (u_long bytes_transferred, + int success, + const void *completion_key, + u_long error = 0); + // ACE_Proactor will call this method when the write completes. + protected: - Result (ACE_Asynch_Write_Stream_Result_Impl *implementation); - // Constrcutor. - - virtual ~Result (void); - // Destructor. - - ACE_Asynch_Write_Stream_Result_Impl *implementation_; - // Implementation class. - }; -}; + u_long bytes_to_write_; + // The number of bytes which were requested at the start of the + // asynchronous write. -// Forward declarations -class ACE_Asynch_Read_File_Impl; -class ACE_Asynch_Read_File_Result_Impl; + ACE_Message_Block &message_block_; + // Message block that contains the data to be written. + + ACE_HANDLE handle_; + // I/O handle used for writing. + }; +}; 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. + // on a file. // // = DESCRIPTION - // // Once <open> is called, multiple asynchronous <read>s can - // started using this class. An ACE_Asynch_Read_File::Result + // started using this class. A 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); + const void *act = 0); // 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 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. - + // at <offset> from the beginning of the file. 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. + // <handler> when the asynchronous read completes. // // = DESCRIPTION - // // This class has all the information necessary for the // <handler> to uniquiely identify the completion of the // asynchronous read. @@ -502,41 +407,40 @@ public: // 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. + friend class ACE_Asynch_Read_File; + // The factory has special privileges. - 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. + // protected: + // + // These two should really be protected. But sometimes it + // simplifies code to be able to "fake" a result. Use carefully. + 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); + // Constructor is protected since creation is limited to + // ACE_Asynch_Read_File factory. + + virtual void complete (u_long bytes_transferred, + int success, + const void *completion_key, + u_long error = 0); + // ACE_Proactor will call this method when the read completes. }; }; -// 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 { +public: // = TITLE - // // This class is a factory for starting off asynchronous writes - // on a file. This class forwards all methods to its - // implementation class. + // on a file. // // = 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 @@ -545,63 +449,23 @@ class ACE_Export ACE_Asynch_Write_File : public ACE_Asynch_Write_Stream // // 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); + const void *act = 0); // 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. + // start at <offset> from the beginning of the file. 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. + // <handler> when the asynchronous write completes. // // = DESCRIPTION - // // This class has all the information necessary for the // <handler> to uniquiely identify the completion of the // asynchronous write. @@ -612,119 +476,91 @@ public: // 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. + friend class ACE_Asynch_Write_File; + // The factory has special privileges. - ACE_Asynch_Write_File_Result_Impl *implementation_; - // The implementation class. + // protected: + // + // These two should really be protected. But sometimes it + // simplifies code to be able to "fake" a result. Use carefully. + 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); + // Constructor is protected since creation is limited to + // ACE_Asynch_Write_File factory. + + virtual void complete (u_long bytes_transferred, + int success, + const void *completion_key, + u_long error = 0); + // ACE_Proactor will call this method when the write completes. }; }; -// 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. + // on a listen handle. // // = 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. - +#if defined (ACE_HAS_AIO_CALLS) 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. - + // (We will also call base class's <open> from here). +#endif /* ACE_HAS_AIO_CALLS */ + 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); + const void *act = 0); // 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. + // handle will be created. // // <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: + friend class ACE_Asynch_Accept; + // The factory has special privileges. + +#if defined (ACE_HAS_AIO_CALLS) + friend class ACE_Asynch_Accept_Handler; + // This factory does it all, so it needs spl privileges. +#endif /* ACE_HAS_AIO_CALLS */ + u_long bytes_to_read (void) const; // The number of bytes which were requested at the start of the // asynchronous accept. @@ -738,34 +574,60 @@ public: 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: + // + // These two should really be protected. But sometimes it + // simplifies code to be able to "fake" a result. Use carefully. + 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); + // Constructor is protected since creation is limited to + // ACE_Asynch_Accept factory. + + virtual void complete (u_long bytes_transferred, + int success, + const void *completion_key, + u_long error = 0); + // ACE_Proactor will call this method when the accept completes. + 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. + u_long bytes_to_read_; + // Bytes requested when the asynchronous read was initiated. + + ACE_Message_Block &message_block_; + // Message block for reading the data into. + + ACE_HANDLE listen_handle_; + // I/O handle used for accepting new connections. + + ACE_HANDLE accept_handle_; + // I/O handle for the new connection. }; -}; -// Forward declarations -class ACE_Asynch_Transmit_File_Result_Impl; -class ACE_Asynch_Transmit_File_Impl; +private: +#if defined (ACE_HAS_AIO_CALLS) + static void* thread_function (void* reactor); + // The thread function that does handle events + + ACE_Reactor reactor_; + // Reactor to wait on the <listen_handle>. + + ACE_Asynch_Accept_Handler* accept_handler_; + // The Event Handler to do handle_input. +#endif /* ACE_HAS_AIO_CALLS */ +}; 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 @@ -778,26 +640,13 @@ class ACE_Export ACE_Asynch_Transmit_File : public ACE_Asynch_Operation // 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. + // Forward declaration. - virtual ~ACE_Asynch_Transmit_File (void); - // Destructor. + ACE_Asynch_Transmit_File (void); + // A "do-nothing" constructor. - 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, @@ -805,9 +654,7 @@ public: 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); + const void *act = 0); // 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 @@ -816,46 +663,23 @@ public: // 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. + // documentation on what the flags should be. 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: + friend class ACE_Asynch_Transmit_File; + // The factory has special privileges. + ACE_HANDLE socket (void) const; // Socket used for transmitting the file. @@ -864,53 +688,79 @@ public: 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: + // + // These two should really be protected. But sometimes it + // simplifies code to be able to "fake" a result. Use carefully. + Result (ACE_Handler &handler, + ACE_HANDLE socket, + ACE_HANDLE 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); + // 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 = 0); + // ACE_Proactor will call this method when the write completes. + protected: - Result (ACE_Asynch_Transmit_File_Result_Impl *implementation); - // Constructor. + ACE_HANDLE socket_; + // Network I/O handle. + + ACE_HANDLE file_; + // File I/O handle. + + 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. - virtual ~Result (void); - // Destructor. - - ACE_Asynch_Transmit_File_Result_Impl *implementation_; - // The implementation class. + 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. }; 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, @@ -958,14 +808,11 @@ public: 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. @@ -1002,12 +849,7 @@ public: 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. + // <act> is the ACT passed when scheduling the timer ACE_Proactor *proactor (void); // Get the proactor associated with this handler. @@ -1019,37 +861,30 @@ public: // 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 +// Forward declartion 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. - +public: 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. |