Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Related Pages  

POSIX_Asynch_IO.h

Go to the documentation of this file.
00001 /* -*- C++ -*- */
00002 
00003 //=============================================================================
00004 /**
00005  *  @file    POSIX_Asynch_IO.h
00006  *
00007  *  $Id: POSIX_Asynch_IO.h,v 1.1.1.4 2003/02/21 18:36:32 chad Exp $
00008  *
00009  *  The implementation classes for POSIX implementation of Asynch
00010  *  Operations are defined here in this file.
00011  *
00012  *  @author Irfan Pyarali <irfan@cs.wustl.edu>
00013  *  @author Tim Harrison <harrison@cs.wustl.edu>
00014  *  @author Alexander Babu Arulanthu <alex@cs.wustl.edu>
00015  *  @author Roger Tragin <r.tragin@computer.org>
00016  *  @author Alexander Libman <alibman@baltimore.com>
00017  */
00018 //=============================================================================
00019 
00020 #ifndef ACE_POSIX_ASYNCH_IO_H
00021 #define ACE_POSIX_ASYNCH_IO_H
00022 
00023 #include "ace/config-all.h"
00024 
00025 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00026 #pragma once
00027 #endif /* ACE_LACKS_PRAGMA_ONCE */
00028 
00029 #if defined (ACE_HAS_AIO_CALLS)
00030 
00031 #include "ace/OS.h"
00032 
00033 #include "ace/Asynch_IO_Impl.h"
00034 #include "ace/Unbounded_Queue.h"
00035 #include "ace/Map_Manager.h"
00036 
00037 // Forward declarations
00038 class ACE_POSIX_Proactor;
00039 class ACE_Proactor_Impl;
00040 class ACE_Handle_Set;
00041 
00042 /**
00043  * @class ACE_POSIX_Asynch_Result
00044  *
00045  * This class provides concrete implementation for ACE_Asynch_Result
00046  * for POSIX4 platforms. This class extends @c aiocb and makes it more
00047  * useful.
00048  */
00049 class ACE_Export ACE_POSIX_Asynch_Result : public virtual ACE_Asynch_Result_Impl,
00050                                            public aiocb
00051 {
00052 public:
00053   /// Number of bytes transferred by the operation.
00054   size_t bytes_transferred (void) const;
00055 
00056   /// ACT associated with the operation.
00057   const void *act (void) const;
00058 
00059   /// Did the operation succeed?
00060   int success (void) const;
00061 
00062   /**
00063    * This is the ACT associated with the handle on which the
00064    * Asynch_Operation takes place.
00065    *
00066    * @@ This is not implemented for POSIX4 platforms.
00067    *
00068    */
00069   const void *completion_key (void) const;
00070 
00071   /// Error value if the operation fail.
00072   u_long error (void) const;
00073 
00074   /// This returns ACE_INVALID_HANDLE on POSIX4 platforms.
00075   ACE_HANDLE event (void) const;
00076 
00077   /**
00078    * This really make sense only when doing file I/O.
00079    *
00080    * @@ On POSIX4-Unix, offset_high should be supported using
00081    *     aiocb64.
00082    *
00083    */
00084   u_long offset (void) const;
00085   u_long offset_high (void) const;
00086 
00087   /// Priority of the operation.
00088   int priority (void) const;
00089 
00090   /**
00091    * POSIX4 realtime signal number to be used for the
00092    * operation. <signal_number> ranges from SIGRTMIN to SIGRTMAX. By
00093    * default, SIGRTMIN is used to issue <aio_> calls.
00094    */
00095   int signal_number (void) const;
00096 
00097   /// Post <this> to the Proactor.
00098   int post_completion (ACE_Proactor_Impl *proactor);
00099 
00100   /// Destructor.
00101   virtual ~ACE_POSIX_Asynch_Result (void);
00102 
00103   /// Simulate error value to use in the post_completion ()
00104   void set_error (u_long errcode);
00105 
00106   /// Simulate value to use in the post_completion ()
00107   void set_bytes_transferred (size_t nbytes);
00108 
00109 protected:
00110   /// Constructor. <Event> is not used on POSIX.
00111   ACE_POSIX_Asynch_Result (ACE_Handler &handler,
00112                            const void* act,
00113                            ACE_HANDLE event,
00114                            u_long offset,
00115                            u_long offset_high,
00116                            int priority,
00117                            int signal_number);
00118 
00119   /// Handler that will be called back.
00120   ACE_Handler &handler_;
00121 
00122   /**
00123    * ACT for this operation.
00124    * We could use <aiocb::aio_sigevent.sigev_value.sival_ptr> for
00125    * this. But it doesnot provide the constness, so this may be
00126    * better.
00127    */
00128   const void *act_;
00129 
00130   /// Bytes transferred by this operation.
00131   size_t bytes_transferred_;
00132 
00133   /// Success indicator.
00134   int success_;
00135 
00136   /// ACT associated with handle.
00137   const void *completion_key_;
00138 
00139   /// Error if operation failed.
00140   u_long error_;
00141 };
00142 
00143 /**
00144  * @class ACE_POSIX_Asynch_Operation
00145  *
00146  * @brief This class implements <ACE_Asynch_Operation> for all
00147  * implementations of Proactor (AIOCB, SIG, SUN)
00148  * Specific future implementations
00149  * can derive from this class.
00150  */
00151 class ACE_Export ACE_POSIX_Asynch_Operation : public virtual ACE_Asynch_Operation_Impl
00152 {
00153 public:
00154   /**
00155    * Initializes the factory with information which will be used with
00156    * each asynchronous call.  If (<handle> == ACE_INVALID_HANDLE),
00157    * <ACE_Handler::handle> will be called on the <handler> to get the
00158    * correct handle. No need for the Proactor since the sub classes
00159    * will know the correct implementation Proactor class, since this
00160    * Operation class itself was created by the correct implementation
00161    * Proactor class.
00162    */
00163   int open (ACE_Handler &handler,
00164             ACE_HANDLE handle,
00165             const void *completion_key,
00166             ACE_Proactor *proactor = 0);
00167 
00168   /// Check the documentation for <ACE_Asynch_Operation::cancel>.
00169   int cancel (void);
00170 
00171   // = Access methods.
00172 
00173   /// Return the underlying proactor.
00174   ACE_Proactor* proactor (void) const;
00175 
00176   /// Return the underlying Proactor implementation.
00177   ACE_POSIX_Proactor * posix_proactor (void) const;
00178 
00179 protected:
00180   /// Contructor.
00181   ACE_POSIX_Asynch_Operation (ACE_POSIX_Proactor *posix_proactor);
00182 
00183   /// Destructor.
00184   virtual ~ACE_POSIX_Asynch_Operation (void);
00185 
00186   // This call is for the POSIX implementation. This method is used by
00187   // <ACE_Asynch_Operation> to store some information with the
00188   // Proactor after an <aio_> call is issued, so that the Proactor can
00189   // retreve this information to do <aio_return> and <aio_error>.
00190   // Passing a '0' ptr returns the status, indicating whether there
00191   // are slots available or no. Passing a valid ptr stores the ptr
00192   // with the Proactor.
00193 
00194   /**
00195    * It is easy to get this specific implementation proactor here,
00196    * since it is the one that creates the correct POSIX_Asynch_*
00197    * objects. We can use this to get to the implementation proactor
00198    * directly.
00199    */
00200   ACE_POSIX_Proactor *posix_proactor_;
00201 
00202   /// Proactor that this Asynch IO will be registered with.
00203   ACE_Proactor *proactor_;
00204 
00205   /// Handler that will receive the callback.
00206   ACE_Handler *handler_;
00207 
00208   /// I/O handle used for reading.
00209   ACE_HANDLE handle_;
00210 };
00211 
00212 /**
00213  * @class ACE_POSIX_Asynch_Read_Stream_Result
00214  *
00215  * @brief This class provides concrete implementation for
00216  *    <ACE_Asynch_Read_Stream::Result> class for POSIX platforms.
00217  */
00218 class ACE_Export ACE_POSIX_Asynch_Read_Stream_Result : public virtual ACE_Asynch_Read_Stream_Result_Impl,
00219                                                        public ACE_POSIX_Asynch_Result
00220 {
00221 
00222   /// Factory classes will have special permissions.
00223   friend class ACE_POSIX_Asynch_Read_Stream;
00224 
00225   /// The Proactor constructs the Result class for faking results.
00226   friend class ACE_POSIX_Proactor;
00227 
00228 public:
00229   /// The number of bytes which were requested at the start of the
00230   /// asynchronous read.
00231   size_t bytes_to_read (void) const;
00232 
00233   /// Message block which contains the read data.
00234   ACE_Message_Block &message_block (void) const;
00235 
00236   /// I/O handle used for reading.
00237   ACE_HANDLE handle (void) const;
00238 
00239 protected:
00240   ACE_POSIX_Asynch_Read_Stream_Result (ACE_Handler &handler,
00241                                        ACE_HANDLE handle,
00242                                        ACE_Message_Block &message_block,
00243                                        size_t bytes_to_read,
00244                                        const void* act,
00245                                        ACE_HANDLE event,
00246                                        int priority,
00247                                        int signal_number);
00248   // Constructor is protected since creation is limited to
00249   // ACE_Asynch_Read_Stream factory.
00250 
00251   /// Get the data copied to this class, before calling application
00252   /// handler.
00253   virtual void complete (size_t bytes_transferred,
00254                          int success,
00255                          const void *completion_key,
00256                          u_long error);
00257 
00258   /// Destructor.
00259   virtual ~ACE_POSIX_Asynch_Read_Stream_Result (void);
00260 
00261   // aiocb::aio_nbytes
00262   // Bytes requested when the asynchronous read was initiated.
00263 
00264   /// Message block for reading the data into.
00265   ACE_Message_Block &message_block_;
00266 
00267   // aiocb::aio_filedes
00268   // I/O handle used for reading.
00269 };
00270 
00271 /**
00272  * @class ACE_POSIX_Asynch_Read_Stream
00273  *
00274  * This class implements <ACE_Asynch_Read_Stream> for all POSIX
00275  * based implementation of Proactor.
00276  *
00277  */
00278 class ACE_Export ACE_POSIX_Asynch_Read_Stream : public virtual ACE_Asynch_Read_Stream_Impl,
00279                                                 public ACE_POSIX_Asynch_Operation
00280 {
00281 public:
00282   /// Constructor.
00283   ACE_POSIX_Asynch_Read_Stream (ACE_POSIX_Proactor *posix_proactor);
00284 
00285   /// This starts off an asynchronous read.  Upto <bytes_to_read> will
00286   /// be read and stored in the <message_block>.
00287   int read (ACE_Message_Block &message_block,
00288             size_t bytes_to_read,
00289             const void *act,
00290             int priority,
00291             int signal_number = 0);
00292 
00293   /// Destructor.
00294   virtual ~ACE_POSIX_Asynch_Read_Stream (void);
00295 };
00296 
00297 
00298 /**
00299  * @class ACE_POSIX_Asynch_Write_Stream_Result
00300  *
00301  * @brief This class provides concrete implementation for
00302  *     <ACE_Asynch_Write_Stream::Result> on POSIX platforms.
00303  *
00304  *
00305  *     This class has all the information necessary for the
00306  *     <handler> to uniquiely identify the completion of the
00307  *     asynchronous write.
00308  */
00309 class ACE_Export ACE_POSIX_Asynch_Write_Stream_Result : public virtual ACE_Asynch_Write_Stream_Result_Impl,
00310                                                         public ACE_POSIX_Asynch_Result
00311 {
00312   /// Factory classes will have special privilages.
00313   friend class ACE_POSIX_Asynch_Write_Stream;
00314 
00315   /// The Proactor constructs the Result class for faking results.
00316   friend class ACE_POSIX_Proactor;
00317 
00318 public:
00319   /// The number of bytes which were requested at the start of the
00320   /// asynchronous write.
00321   size_t bytes_to_write (void) const;
00322 
00323   /// Message block that contains the data to be written.
00324   ACE_Message_Block &message_block (void) const;
00325 
00326   /// I/O handle used for writing.
00327   ACE_HANDLE handle (void) const;
00328 
00329 protected:
00330   /// Constructor is protected since creation is limited to
00331   /// ACE_Asynch_Write_Stream factory.
00332   ACE_POSIX_Asynch_Write_Stream_Result (ACE_Handler &handler,
00333                                         ACE_HANDLE handle,
00334                                         ACE_Message_Block &message_block,
00335                                         size_t bytes_to_write,
00336                                         const void* act,
00337                                         ACE_HANDLE event,
00338                                         int priority,
00339                                         int signal_number);
00340 
00341   /// ACE_Proactor will call this method when the write completes.
00342   virtual void complete (size_t bytes_transferred,
00343                          int success,
00344                          const void *completion_key,
00345                          u_long error);
00346 
00347   /// Destructor.
00348   virtual ~ACE_POSIX_Asynch_Write_Stream_Result (void);
00349 
00350 protected:
00351   // aiocb::aio_nbytes
00352   // The number of bytes which were requested at the start of the
00353   // asynchronous write.
00354 
00355   /// Message block that contains the data to be written.
00356   ACE_Message_Block &message_block_;
00357 
00358   // aiocb::aio_filedes
00359   // I/O handle used for writing.
00360 };
00361 
00362 /**
00363  * @class ACE_POSIX_Asynch_Write_Stream
00364  *
00365  * @brief This class implements <ACE_Asynch_Write_Stream> for
00366  *  all POSIX implementations of ACE_Proactor.
00367  */
00368 class ACE_Export ACE_POSIX_Asynch_Write_Stream : public virtual ACE_Asynch_Write_Stream_Impl,
00369                                                  public ACE_POSIX_Asynch_Operation
00370 {
00371 public:
00372   /// Constructor.
00373   ACE_POSIX_Asynch_Write_Stream (ACE_POSIX_Proactor *posix_proactor);
00374 
00375   /// This starts off an asynchronous write.  Upto <bytes_to_write>
00376   /// will be written from the <message_block>.
00377   int write (ACE_Message_Block &message_block,
00378              size_t bytes_to_write,
00379              const void *act,
00380              int priority,
00381              int signal_number = 0);
00382 
00383   /// Destructor.
00384   virtual ~ACE_POSIX_Asynch_Write_Stream (void);
00385 };
00386 
00387 /**
00388  * @class ACE_POSIX_Asynch_Read_File_Result
00389  *
00390  * @brief This class provides concrete implementation for
00391  *     <ACE_Asynch_Read_File::Result> class for POSIX platforms.
00392  */
00393 class ACE_Export ACE_POSIX_Asynch_Read_File_Result : public virtual ACE_Asynch_Read_File_Result_Impl,
00394                                                      public ACE_POSIX_Asynch_Read_Stream_Result
00395 {
00396   /// Factory classes will have special permissions.
00397   friend class ACE_POSIX_Asynch_Read_File;
00398 
00399   /// The Proactor constructs the Result class for faking results.
00400   friend class ACE_POSIX_Proactor;
00401 
00402 public:
00403 
00404 protected:
00405   /// Constructor is protected since creation is limited to
00406   /// ACE_Asynch_Read_File factory.
00407   ACE_POSIX_Asynch_Read_File_Result (ACE_Handler &handler,
00408                                      ACE_HANDLE handle,
00409                                      ACE_Message_Block &message_block,
00410                                      size_t bytes_to_read,
00411                                      const void* act,
00412                                      u_long offset,
00413                                      u_long offset_high,
00414                                      ACE_HANDLE event,
00415                                      int priority,
00416                                      int signal_number);
00417 
00418   /// ACE_Proactor will call this method when the read completes.
00419   virtual void complete (size_t bytes_transferred,
00420                          int success,
00421                          const void *completion_key,
00422                          u_long error);
00423 
00424   /// Destructor.
00425   virtual ~ACE_POSIX_Asynch_Read_File_Result (void);
00426 };
00427 
00428 /**
00429  * @class ACE_POSIX_Asynch_Read_File
00430  *
00431  * @brief This class is a factory for starting off asynchronous reads
00432  *     on a file. This class implements <ACE_Asynch_Read_File> for
00433  *     all POSIX implementations of Proactor.
00434  *
00435  *     Once <open> is called, multiple asynchronous <read>s can
00436  *     started using this class.  A <ACE_Asynch_Read_File::Result>
00437  *     will be passed back to the <handler> when the asynchronous
00438  *     reads completes through the <ACE_Handler::handle_read_file>
00439  *     callback.
00440  *
00441  *     This class differs slightly from <ACE_Asynch_Read_Stream> as it
00442  *     allows the user to specify an offset for the read.
00443  */
00444 class ACE_Export ACE_POSIX_Asynch_Read_File : public virtual ACE_Asynch_Read_File_Impl,
00445                                               public ACE_POSIX_Asynch_Read_Stream
00446 {
00447 
00448 public:
00449   /// Constructor.
00450   ACE_POSIX_Asynch_Read_File (ACE_POSIX_Proactor *posix_proactor);
00451 
00452   /**
00453    * This starts off an asynchronous read.  Upto <bytes_to_read> will
00454    * be read and stored in the <message_block>.  The read will start
00455    * at <offset> from the beginning of the file.
00456    */
00457   int read (ACE_Message_Block &message_block,
00458             size_t bytes_to_read,
00459             u_long offset,
00460             u_long offset_high,
00461             const void *act,
00462             int priority,
00463             int signal_number = 0);
00464 
00465   /// Destructor.
00466   virtual ~ACE_POSIX_Asynch_Read_File (void);
00467 
00468 private:
00469   /**
00470    * This belongs to ACE_POSIX_Asynch_Read_Stream. We have
00471    * defined this here to avoid compiler warnings and forward the
00472    * method to <ACE_POSIX_Asynch_Read_Stream::read>.
00473    */
00474   int read (ACE_Message_Block &message_block,
00475             size_t bytes_to_read,
00476             const void *act,
00477             int priority,
00478             int signal_number = 0);
00479 };
00480 
00481 
00482 /**
00483  * @class ACE_POSIX_Asynch_Write_File_Result
00484  *
00485  * @brief This class provides implementation for
00486  *     <ACE_Asynch_Write_File_Result> for POSIX platforms.
00487  *
00488  *     This class has all the information necessary for the
00489  *     <handler> to uniquiely identify the completion of the
00490  *     asynchronous write.
00491  *
00492  *     This class differs slightly from
00493  *     <ACE_Asynch_Write_Stream::Result> as it calls back
00494  *     <ACE_Handler::handle_write_file> on the <handler> instead of
00495  *     <ACE_Handler::handle_write_stream>.  No additional state is
00496  *     required by this class as <ACE_Asynch_Result> can store the
00497  *     <offset>.
00498  */
00499 class ACE_Export ACE_POSIX_Asynch_Write_File_Result : public virtual ACE_Asynch_Write_File_Result_Impl,
00500                                                       public ACE_POSIX_Asynch_Write_Stream_Result
00501 {
00502   /// Factory classes will have special permissions.
00503   friend class ACE_POSIX_Asynch_Write_File;
00504 
00505   /// The Proactor constructs the Result class for faking results.
00506   friend class ACE_POSIX_Proactor;
00507 
00508 protected:
00509   /// Constructor is protected since creation is limited to
00510   /// ACE_Asynch_Write_File factory.
00511   ACE_POSIX_Asynch_Write_File_Result (ACE_Handler &handler,
00512                                       ACE_HANDLE handle,
00513                                       ACE_Message_Block &message_block,
00514                                       size_t bytes_to_write,
00515                                       const void* act,
00516                                       u_long offset,
00517                                       u_long offset_high,
00518                                       ACE_HANDLE event,
00519                                       int priority,
00520                                       int signal_number);
00521 
00522   /// ACE_Proactor will call this method when the write completes.
00523   virtual void complete (size_t bytes_transferred,
00524                          int success,
00525                          const void *completion_key,
00526                          u_long error);
00527 
00528   /// Destructor.
00529   virtual ~ACE_POSIX_Asynch_Write_File_Result (void);
00530 };
00531 
00532 /**
00533  * @class ACE_POSIX_Asynch_Write_File
00534  *
00535  *     This class provides concrete implementation for
00536  *     <ACE_Asynch_Write_File> for POSIX platforms where the
00537  *     completion strategy for Proactor is based on AIOCB (AIO
00538  *     Control Blocks).
00539  *
00540  */
00541 class ACE_Export ACE_POSIX_Asynch_Write_File : public virtual ACE_Asynch_Write_File_Impl,
00542                                                public ACE_POSIX_Asynch_Write_Stream
00543 {
00544 public:
00545   /// Constructor.
00546   ACE_POSIX_Asynch_Write_File (ACE_POSIX_Proactor *posix_proactor);
00547 
00548   /**
00549    * This starts off an asynchronous write.  Upto <bytes_to_write>
00550    * will be written and stored in the <message_block>.  The write will
00551    * start at <offset> from the beginning of the file.
00552    */
00553   int write (ACE_Message_Block &message_block,
00554              size_t bytes_to_write,
00555              u_long offset,
00556              u_long offset_high,
00557              const void *act,
00558              int priority,
00559              int signal_number = 0);
00560 
00561   /// Destructor.
00562   virtual ~ACE_POSIX_Asynch_Write_File (void);
00563 
00564 private:
00565   /**
00566    * This <write> belongs to ACE_POSIX_Asynch_Write_Stream. We
00567    * have put this here to avoid compiler warnings. We forward this
00568    * method call to the <ACE_POSIX_Asynch_Write_Stream::write>
00569    * one.
00570    */
00571   int write (ACE_Message_Block &message_block,
00572              size_t bytes_to_write,
00573              const void *act,
00574              int priority,
00575              int signal_number = 0);
00576 };
00577 
00578 /**
00579  * @class ACE_POSIX_Asynch_Accept_Result
00580  *
00581  * @brief This is that class which will be passed back to the
00582  *     <handler> when the asynchronous accept completes.
00583  *
00584  *
00585  *     This class has all the information necessary for the
00586  *     <handler> to uniquiely identify the completion of the
00587  *     asynchronous accept.
00588  */
00589 class ACE_Export ACE_POSIX_Asynch_Accept_Result : public virtual ACE_Asynch_Accept_Result_Impl,
00590                                                   public ACE_POSIX_Asynch_Result
00591 {
00592   /// Factory classes will have special permissions.
00593   friend class ACE_POSIX_Asynch_Accept;
00594 
00595   /// The Proactor constructs the Result class for faking results.
00596   friend class ACE_POSIX_Proactor;
00597 
00598 public:
00599   /// The number of bytes which were requested at the start of the
00600   /// asynchronous accept.
00601   size_t bytes_to_read (void) const;
00602 
00603   /// Message block which contains the read data.
00604   ACE_Message_Block &message_block (void) const;
00605 
00606   /// I/O handle used for accepting new connections.
00607   ACE_HANDLE listen_handle (void) const;
00608 
00609   /// I/O handle for the new connection.
00610   ACE_HANDLE accept_handle (void) const;
00611 
00612 protected:
00613   /// Constructor is protected since creation is limited to
00614   /// ACE_Asynch_Accept factory.
00615   ACE_POSIX_Asynch_Accept_Result (ACE_Handler &handler,
00616                                   ACE_HANDLE listen_handle,
00617                                   ACE_HANDLE accept_handle,
00618                                   ACE_Message_Block &message_block,
00619                                   size_t bytes_to_read,
00620                                   const void* act,
00621                                   ACE_HANDLE event,
00622                                   int priority,
00623                                   int signal_number);
00624 
00625   /// ACE_Proactor will call this method when the accept completes.
00626   virtual void complete (size_t bytes_transferred,
00627                          int success,
00628                          const void *completion_key,
00629                          u_long error);
00630 
00631   /// Destructor.
00632   virtual ~ACE_POSIX_Asynch_Accept_Result (void);
00633 
00634   // aiocb::aio_nbytes
00635   // Bytes requested when the asynchronous read was initiated.
00636   // Actually, on POSIX implementation, we dont read any intial data.
00637 
00638   /// Message block for reading the data into.
00639   ACE_Message_Block &message_block_;
00640 
00641   /// I/O handle used for accepting new connections.
00642   ACE_HANDLE listen_handle_;
00643 
00644   // aiocb::aio_filedes
00645   // I/O handle for the new connection.
00646 };
00647 
00648 
00649 /**
00650  * @class ACE_POSIX_Asynch_Accept
00651  *
00652  * @brief For the POSIX implementation this class is common for all Proactors
00653  * (AIOCB/SIG/SUN)
00654  */
00655 class ACE_Export ACE_POSIX_Asynch_Accept :
00656   public virtual ACE_Asynch_Accept_Impl,
00657   public ACE_POSIX_Asynch_Operation,
00658   public ACE_Event_Handler
00659 {
00660 public:
00661 
00662   /// Constructor.
00663   ACE_POSIX_Asynch_Accept (ACE_POSIX_Proactor * posix_proactor);
00664 
00665   /// Destructor.
00666   virtual ~ACE_POSIX_Asynch_Accept (void);
00667 
00668  /**
00669    * This <open> belongs to ACE_POSIX_Asynch_Operation. We forward
00670    * this call to that method. We have put this here to avoid the
00671    * compiler warnings.
00672    */
00673   int open (ACE_Handler &handler,
00674             ACE_HANDLE handle,
00675             const void *completion_key,
00676             ACE_Proactor *proactor = 0);
00677 
00678   /**
00679    * This starts off an asynchronous accept.  The asynchronous accept
00680    * call also allows any initial data to be returned to the
00681    * <handler>.  Upto <bytes_to_read> will be read and stored in the
00682    * <message_block>.  The <accept_handle> will be used for the
00683    * <accept> call.  If (<accept_handle> == INVALID_HANDLE), a new
00684    * handle will be created.
00685    *
00686    * <message_block> must be specified. This is because the address of
00687    * the new connection is placed at the end of this buffer.
00688    */
00689   int accept (ACE_Message_Block &message_block,
00690               size_t bytes_to_read,
00691               ACE_HANDLE accept_handle,
00692               const void *act,
00693               int priority,
00694               int signal_number = 0);
00695 
00696   /**
00697    *  Cancel all pending pseudo-asynchronus requests
00698    *  Behavior as usual AIO request
00699    */
00700   int cancel (void);
00701 
00702   /**
00703    *  Close performs cancellation of all pending requests
00704    *  and closure the listen handle
00705    */
00706   int close ();
00707 
00708   /// virtual from ACE_Event_Handler
00709   ACE_HANDLE get_handle (void) const;
00710 
00711   /// virtual from ACE_Event_Handler
00712   void set_handle (ACE_HANDLE handle);
00713 
00714   /// virtual from ACE_Event_Handler
00715   /// Called when accept event comes up on <listen_handle>
00716   int handle_input (ACE_HANDLE handle);
00717 
00718   /// virtual from ACE_Event_Handler
00719   int handle_close (ACE_HANDLE handle, ACE_Reactor_Mask close_mask);
00720 
00721 private:
00722   /// flg_notify points whether or not we should send notification about
00723   /// canceled accepts
00724   ///  Parameter flg_notify can be
00725   ///    0  - don't send notifications about canceled accepts
00726   ///    1  - notify user about canceled accepts
00727   ///         according POSIX standards we should receive notifications
00728   ///         on canceled AIO requests
00729   int cancel_uncompleted (int flg_notify);
00730 
00731   /// 1 - Accept is registered in ACE_Asynch_Pseudo_Task
00732   /// 0 - Aceept is deregisted in ACE_Asynch_Pseudo_Task
00733   int flg_open_ ;
00734 
00735   /// To prevent ACE_Asynch_Pseudo_Task from deletion
00736   /// while we make a call to the ACE_Asynch_Pseudo_Task
00737   /// This is extra cost !!!
00738   /// we could avoid them if all applications will follow the rule:
00739   /// Proactor should be deleted only after deletion all
00740   /// AsynchOperation objects connected with it
00741   int  task_lock_count_;
00742 
00743   /// Queue of Result pointers that correspond to all the pending
00744   /// accept operations.
00745   ACE_Unbounded_Queue<ACE_POSIX_Asynch_Accept_Result*> result_queue_;
00746 
00747   /// The lock to protect the result queue which is shared. The queue
00748   /// is updated by main thread in the register function call and
00749   /// through the auxillary thread in the deregister fun. So let us
00750   /// mutex it.
00751   ACE_SYNCH_MUTEX lock_;
00752 };
00753 
00754 /**
00755  * @class ACE_POSIX_Asynch_Connect_Result
00756  *
00757  * @brief This is that class which will be passed back to the
00758  *     completion handler when the asynchronous connect completes.
00759  *
00760  *     This class has all the information necessary for a
00761  *     completion handler to uniquely identify the completion of the
00762  *     asynchronous connect.
00763  */
00764 class ACE_Export ACE_POSIX_Asynch_Connect_Result : public virtual ACE_Asynch_Connect_Result_Impl,
00765                                                   public ACE_POSIX_Asynch_Result
00766 {
00767   /// Factory classes will have special permissions.
00768   friend class ACE_POSIX_Asynch_Connect;
00769 
00770   /// The Proactor constructs the Result class for faking results.
00771   friend class ACE_POSIX_Proactor;
00772 
00773 public:
00774 
00775   /// I/O handle for the  connection.
00776   ACE_HANDLE connect_handle (void) const;
00777 
00778 protected:
00779   /// Constructor is protected since creation is limited to
00780   /// ACE_Asynch_Connect factory.
00781   ACE_POSIX_Asynch_Connect_Result (ACE_Handler &handler,
00782                                    ACE_HANDLE  connect_handle,
00783                                    const void* act,
00784                                    ACE_HANDLE  event,
00785                                    int priority,
00786                                    int signal_number);
00787 
00788   /// ACE_Proactor will call this method when the accept completes.
00789   virtual void complete (size_t bytes_transferred,
00790                          int success,
00791                          const void *completion_key,
00792                          u_long error);
00793 
00794   /// Destructor.
00795   virtual ~ACE_POSIX_Asynch_Connect_Result (void);
00796 
00797   // aiocb::aio_filedes
00798   // I/O handle for the new connection.
00799   void connect_handle (ACE_HANDLE handle);
00800 };
00801 
00802 
00803 /**
00804  * @class ACE_POSIX_Asynch_Connect
00805  *
00806  */
00807 class ACE_Export ACE_POSIX_Asynch_Connect :
00808   public virtual ACE_Asynch_Connect_Impl,
00809   public ACE_POSIX_Asynch_Operation,
00810   public ACE_Event_Handler
00811 {
00812 public:
00813 
00814   /// Constructor.
00815   ACE_POSIX_Asynch_Connect (ACE_POSIX_Proactor * posix_proactor);
00816 
00817   /// Destructor.
00818   virtual ~ACE_POSIX_Asynch_Connect (void);
00819 
00820  /**
00821    * This belongs to ACE_POSIX_Asynch_Operation. We forward
00822    * this call to that method. We have put this here to avoid the
00823    * compiler warnings.
00824    */
00825   int open (ACE_Handler &handler,
00826             ACE_HANDLE handle,
00827             const void *completion_key,
00828             ACE_Proactor *proactor = 0);
00829 
00830   /**
00831    * This starts off an asynchronous connect.
00832    *
00833    * @arg connect_handle   will be used for the connect call.  If
00834    *                       ACE_INVALID_HANDLE is specified, a new
00835    *                       handle will be created.
00836    */
00837   int connect (ACE_HANDLE connect_handle,
00838                const ACE_Addr &remote_sap,
00839                const ACE_Addr &local_sap,
00840                int reuse_addr,
00841                const void *act,
00842                int priority,
00843                int signal_number = 0);
00844 
00845   /**
00846    *  Cancel all pending pseudo-asynchronus requests
00847    *  Behavior as usual AIO request
00848    */
00849   int cancel (void);
00850 
00851   /**
00852    *  Close performs cancellation of all pending requests.
00853    */
00854   int close (void);
00855 
00856   /// virtual from ACE_Event_Handler
00857   ACE_HANDLE get_handle (void) const;
00858 
00859   /// virtual from ACE_Event_Handler
00860   void set_handle (ACE_HANDLE handle);
00861 
00862   /// virtual from ACE_Event_Handler
00863   /// Called when accept event comes up on <listen_hanlde>
00864   int handle_input (ACE_HANDLE handle);
00865   int handle_output (ACE_HANDLE handle);
00866   int handle_exception (ACE_HANDLE handle);
00867 
00868   /// virtual from ACE_Event_Handler
00869   int handle_close (ACE_HANDLE handle, ACE_Reactor_Mask close_mask) ;
00870 
00871 private:
00872   int connect_i (ACE_POSIX_Asynch_Connect_Result *result,
00873                  const ACE_Addr & remote_sap,
00874                  const ACE_Addr & local_sap,
00875                  int reuse_addr);
00876 
00877   int post_result (ACE_POSIX_Asynch_Connect_Result *result, int flg_post);
00878 
00879   /// Cancel uncompleted connect operations.
00880   /**
00881    *  @arg flg_notify  Indicates whether or not we should send notification
00882    *                   about canceled accepts.  If this is 0, don't send
00883    *                   notifications about canceled connects.  If 1, notify
00884    *                   user about canceled connects according POSIX
00885    *                   standards we should receive notifications on canceled
00886    *                   AIO requests.
00887    */
00888   int cancel_uncompleted (int flg_notify, ACE_Handle_Set & set);
00889 
00890   int flg_open_ ;
00891   /// 1 - Connect is registered in ACE_Asynch_Pseudo_Task
00892   /// 0 - Aceept is deregisted in ACE_Asynch_Pseudo_Task
00893 
00894 
00895   /// to prevent ACE_Asynch_Pseudo_Task from deletion
00896   /// while we make a call to the ACE_Asynch_Pseudo_Task
00897   /// This is extra cost !!!
00898   /// we could avoid them if all applications will follow the rule:
00899   /// Proactor should be deleted only after deletion all
00900   ///  AsynchOperation objects connected with it
00901   int  task_lock_count_;
00902 
00903   typedef ACE_Map_Manager<ACE_HANDLE, ACE_POSIX_Asynch_Connect_Result *, ACE_SYNCH_NULL_MUTEX>
00904           MAP_MANAGER;
00905   typedef ACE_Map_Iterator<ACE_HANDLE, ACE_POSIX_Asynch_Connect_Result *, ACE_SYNCH_NULL_MUTEX>
00906           MAP_ITERATOR;
00907   typedef ACE_Map_Entry<ACE_HANDLE, ACE_POSIX_Asynch_Connect_Result *>
00908           MAP_ENTRY;
00909 
00910   /// Map of Result pointers that correspond to all the <accept>'s
00911   /// pending.
00912   MAP_MANAGER result_map_;
00913 
00914   /// The lock to protect the result queue which is shared. The queue
00915   /// is updated by main thread in the register function call and
00916   /// through the auxillary thread  in the deregister fun. So let us
00917   /// mutex it.
00918   ACE_SYNCH_MUTEX lock_;
00919 };
00920 
00921 
00922 /**
00923  * @class ACE_POSIX_Asynch_Transmit_File_Result
00924  *
00925  * @brief This is that class which will be passed back to the
00926  *     <handler> when the asynchronous transmit file completes.
00927  *
00928  *     This class has all the information necessary for the
00929  *     <handler> to uniquiely identify the completion of the
00930  *     asynchronous transmit file.
00931  */
00932 class ACE_Export ACE_POSIX_Asynch_Transmit_File_Result : public virtual ACE_Asynch_Transmit_File_Result_Impl,
00933                                                          public ACE_POSIX_Asynch_Result
00934 {
00935   /// Factory classes will have special permissions.
00936   friend class ACE_POSIX_Asynch_Transmit_File;
00937 
00938   /// Handlers do all the job.
00939   friend class ACE_POSIX_Asynch_Transmit_Handler;
00940 
00941   /// The Proactor constructs the Result class for faking results.
00942   friend class ACE_POSIX_Proactor;
00943 
00944 public:
00945   /// Socket used for transmitting the file.
00946   ACE_HANDLE socket (void) const;
00947 
00948   /// File from which the data is read.
00949   ACE_HANDLE file (void) const;
00950 
00951   /// Header and trailer data associated with this transmit file.
00952   ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer (void) const;
00953 
00954   /// The number of bytes which were requested at the start of the
00955   /// asynchronous transmit file.
00956   size_t bytes_to_write (void) const;
00957 
00958   /// Number of bytes per send requested at the start of the transmit
00959   /// file.
00960   size_t bytes_per_send (void) const;
00961 
00962   /// Flags which were passed into transmit file.
00963   u_long flags (void) const;
00964 
00965 protected:
00966   ACE_POSIX_Asynch_Transmit_File_Result (ACE_Handler &handler,
00967                                          ACE_HANDLE socket,
00968                                          ACE_HANDLE file,
00969                                          ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
00970                                          size_t bytes_to_write,
00971                                          u_long offset,
00972                                          u_long offset_high,
00973                                          size_t bytes_per_send,
00974                                          u_long flags,
00975                                          const void *act,
00976                                          ACE_HANDLE event,
00977                                          int priority,
00978                                          int signal_number);
00979   // Constructor is protected since creation is limited to
00980   // ACE_Asynch_Transmit_File factory.
00981 
00982   /// ACE_Proactor will call this method when the write completes.
00983   virtual void complete (size_t bytes_transferred,
00984                          int success,
00985                          const void *completion_key,
00986                          u_long error);
00987 
00988   /// Destructor.
00989   virtual ~ACE_POSIX_Asynch_Transmit_File_Result (void);
00990 
00991   /// Network I/O handle.
00992   ACE_HANDLE socket_;
00993 
00994   // aiocb::aio_filedes
00995   // File I/O handle.
00996 
00997   /// Header and trailer data associated with this transmit file.
00998   ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer_;
00999 
01000   // aiocb::aio_nbytes
01001   // The number of bytes which were requested at the start of the
01002   // asynchronous transmit file.
01003 
01004   /// Number of bytes per send requested at the start of the transmit
01005   /// file.
01006   size_t bytes_per_send_;
01007 
01008   /// Flags which were passed into transmit file.
01009   u_long flags_;
01010 };
01011 
01012 /**
01013  * @class ACE_POSIX_Asynch_Transmit_File
01014  *
01015  * @brief Implementation for transmit_file will make use of
01016  *     POSIX_Asynch_Transmit_Handler.
01017  */
01018 class ACE_Export ACE_POSIX_Asynch_Transmit_File : public virtual ACE_Asynch_Transmit_File_Impl,
01019                                                   public ACE_POSIX_Asynch_Operation
01020 {
01021 public:
01022   /// Constructor.
01023   ACE_POSIX_Asynch_Transmit_File (ACE_POSIX_Proactor *posix_proactor);
01024 
01025   /**
01026    * This starts off an asynchronous transmit file. The <file> is a
01027    * handle to an open file.  <header_and_trailer> is a pointer to a
01028    * data structure that contains pointers to data to send before and
01029    * after the file data is sent.  Set this parameter to 0 if you only
01030    * want to transmit the file data.  Upto <bytes_to_write> will be
01031    * written to the <socket>.  If you want to send the entire file,
01032    * let <bytes_to_write> = 0.  <bytes_per_send> is the size of each
01033    * block of data sent per send operation. Please read the POSIX
01034    * documentation on what the flags should be.
01035    */
01036   int transmit_file (ACE_HANDLE file,
01037                      ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
01038                      size_t bytes_to_write,
01039                      u_long offset,
01040                      u_long offset_high,
01041                      size_t bytes_per_send,
01042                      u_long flags,
01043                      const void *act,
01044                      int priority,
01045                      int signal_number = 0);
01046 
01047   /// Destructor.
01048   virtual ~ACE_POSIX_Asynch_Transmit_File (void);
01049 };
01050 
01051 
01052 /**
01053  * @class ACE_POSIX_Asynch_Read_Dgram
01054  *
01055  * @brief This class is a factory for starting off asynchronous reads
01056  *     on a UDP socket.
01057  *
01058  *     Once <open> is called, multiple asynchronous <read>s can be
01059  *     started using this class.  An ACE_Asynch_Read_Dgram::Result
01060  *     will be passed back to the <handler> when the asynchronous
01061  *     reads completes through the <ACE_Handler::handle_read_stream>
01062  *     callback.
01063  *
01064  */
01065 class ACE_Export ACE_POSIX_Asynch_Read_Dgram : public virtual ACE_Asynch_Read_Dgram_Impl,
01066                                                public ACE_POSIX_Asynch_Operation
01067 {
01068 public:
01069   /// Constructor.
01070   ACE_POSIX_Asynch_Read_Dgram (ACE_POSIX_Proactor *posix_proactor);
01071   virtual ~ACE_POSIX_Asynch_Read_Dgram (void);
01072 
01073   /** This starts off an asynchronous read.  Upto
01074    * <message_block->total_size()> will be read and stored in the
01075    * <message_block>.  <message_block>'s <wr_ptr> will be updated to reflect
01076    * the added bytes if the read operation is successful completed.
01077    * Return code of 1 means immediate success and number_of_bytes_recvd
01078    * will contain number of bytes read.  The <ACE_Handler::handle_read_dgram>
01079    * method will still be called.  Return code of 0 means the IO will
01080    * complete proactively.  Return code of -1 means there was an error, use
01081    * errno to get the error code.
01082    *
01083    * Priority of the operation is specified by <priority>. On POSIX4-Unix,
01084    * this is supported. Works like <nice> in Unix. Negative values are not
01085    * allowed. 0 means priority of the operation same as the process
01086    * priority. 1 means priority of the operation is one less than
01087    * process.  <signal_number> argument is a no-op on non-POSIX4 systems.
01088    */
01089   virtual ssize_t recv (ACE_Message_Block *message_block,
01090                         size_t &number_of_bytes_recvd,
01091                         int flags,
01092                         int protocol_family,
01093                         const void *act,
01094                         int priority,
01095                         int signal_number);
01096 
01097 protected:
01098   /// Do-nothing constructor.
01099   ACE_POSIX_Asynch_Read_Dgram (void);
01100 };
01101 
01102 /**
01103  * @class ACE_POSIX__Asynch_Write_Dgram_Result
01104  *
01105  * @brief This is class provides concrete implementation for
01106  *        ACE_Asynch_Write_Dgram::Result class.
01107  */
01108 class ACE_Export ACE_POSIX_Asynch_Write_Dgram_Result : public virtual ACE_Asynch_Write_Dgram_Result_Impl,
01109                                                        public ACE_POSIX_Asynch_Result
01110 {
01111   /// Factory classes will have special permissions.
01112   friend class ACE_POSIX_Asynch_Write_Dgram;
01113 
01114   /// Proactor class has special permission.
01115   friend class ACE_POSIX_Proactor;
01116 
01117 public:
01118   /// The number of bytes which were requested at the start of the
01119   /// asynchronous write.
01120   size_t bytes_to_write (void) const;
01121 
01122   /// Message block which contains the sent data
01123   ACE_Message_Block *message_block (void) const;
01124 
01125   /// The flags using in the write
01126   int flags (void) const;
01127 
01128   /// I/O handle used for writing.
01129   ACE_HANDLE handle (void) const;
01130 
01131 protected:
01132   /// Constructor is protected since creation is limited to
01133   /// ACE_Asynch_Write_Stream factory.
01134   ACE_POSIX_Asynch_Write_Dgram_Result (ACE_Handler &handler,
01135                                        ACE_HANDLE handle,
01136                                        ACE_Message_Block *message_block,
01137                                        size_t bytes_to_write,
01138                                        int flags,
01139                                        const void* act,
01140                                        ACE_HANDLE event,
01141                                        int priority,
01142                                        int signal_number);
01143 
01144   /// ACE_Proactor will call this method when the write completes.
01145   virtual void complete (size_t bytes_transferred,
01146                          int success,
01147                          const void *completion_key,
01148                          u_long error);
01149 
01150   /// Destructor.
01151   virtual ~ACE_POSIX_Asynch_Write_Dgram_Result (void);
01152 
01153   /// The number of bytes which were requested at the start of the
01154   /// asynchronous write.
01155   size_t bytes_to_write_;
01156 
01157   /// Message block used for the send.
01158   ACE_Message_Block *message_block_;
01159 
01160   /// The flags using in the write
01161   int flags_;
01162 
01163   /// I/O handle used for writing.
01164   ACE_HANDLE handle_;
01165 
01166   };
01167 
01168 /**
01169  * @class ACE_POSIX_Asynch_Write_Dgram
01170  *
01171  * @brief This class is a factory for starting off asynchronous writes
01172  *    on a UDP socket.
01173  *
01174  *     Once <open> is called, multiple asynchronous <writes>s can
01175  *     started using this class.  A ACE_Asynch_Write_Stream::Result
01176  *     will be passed back to the <handler> when the asynchronous
01177  *     write completes through the
01178  *     <ACE_Handler::handle_write_stream> callback.
01179  */
01180 class ACE_Export ACE_POSIX_Asynch_Write_Dgram : public virtual ACE_Asynch_Write_Dgram_Impl,
01181                                                 public ACE_POSIX_Asynch_Operation
01182 {
01183 public:
01184   /// Constructor.
01185   ACE_POSIX_Asynch_Write_Dgram (ACE_POSIX_Proactor *posix_proactor);
01186 
01187   /// Destructor
01188   virtual ~ACE_POSIX_Asynch_Write_Dgram (void);
01189 
01190   /** This starts off an asynchronous send.  Up to
01191    * <message_block->total_length()> will be sent.  <message_block>'s
01192    * <rd_ptr> will be updated to reflect the sent bytes if the send operation
01193    * is successful completed.
01194    * Return code of 1 means immediate success and number_of_bytes_sent
01195    * is updated to number of bytes sent.  The <ACE_Handler::handle_write_dgram>
01196    * method will still be called.  Return code of 0 means the IO will
01197    * complete proactively.  Return code of -1 means there was an error, use
01198    * errno to get the error code.
01199    *
01200    * Priority of the operation is specified by <priority>. On POSIX4-Unix,
01201    * this is supported. Works like <nice> in Unix. Negative values are not
01202    * allowed. 0 means priority of the operation same as the process
01203    * priority. 1 means priority of the operation is one less than
01204    * process. And so forth.  <signal_number> is a no-op on non-POSIX4 systems.
01205    */
01206   virtual ssize_t send (ACE_Message_Block *message_block,
01207                         size_t &number_of_bytes_sent,
01208                         int flags,
01209                         const ACE_Addr &addr,
01210                         const void *act,
01211                         int priority,
01212                         int signal_number);
01213 
01214 protected:
01215   /// Do-nothing constructor.
01216   ACE_POSIX_Asynch_Write_Dgram (void);
01217 };
01218 
01219 
01220 /*****************************************************/
01221 
01222 /**
01223  * @class ACE_POSIX_Asynch_Read_Dgram_Result
01224  *
01225  * @brief This is class provides concrete implementation for
01226  *        ACE_Asynch_Read_Dgram::Result class.
01227  */
01228 class ACE_Export ACE_POSIX_Asynch_Read_Dgram_Result : public virtual ACE_Asynch_Read_Dgram_Result_Impl,
01229                                                       public virtual ACE_POSIX_Asynch_Result
01230 {
01231 
01232   /// Factory classes will have special permissions.
01233   friend class ACE_POSIX_Asynch_Read_Dgram;
01234 
01235   /// Proactor class has special permission.
01236   friend class ACE_POSIX_Proactor;
01237 
01238 public:
01239   /// The number of bytes which were requested at the start of the
01240   /// asynchronous read.
01241   size_t bytes_to_read (void) const;
01242 
01243   /// Message block which contains the read data
01244   ACE_Message_Block *message_block (void) const;
01245 
01246   /// The address of where the packet came from
01247   int remote_address (ACE_Addr& addr) const;
01248 
01249   sockaddr *saddr (void) const;
01250 
01251   /// The flags used in the read
01252   int flags (void) const;
01253 
01254   /// I/O handle used for reading.
01255   ACE_HANDLE handle (void) const;
01256 
01257 protected:
01258   /// Constructor is protected since creation is limited to
01259   /// ACE_Asynch_Read_Dgram factory.
01260   ACE_POSIX_Asynch_Read_Dgram_Result (ACE_Handler &handler,
01261                                       ACE_HANDLE handle,
01262                                       ACE_Message_Block *message_block,
01263                                       size_t bytes_to_read,
01264                                       int flags,
01265                                       int protocol_family,
01266                                       const void* act,
01267                                       ACE_HANDLE event,
01268                                       int priority,
01269                                       int signal_number = 0);
01270 
01271   /// Proactor will call this method when the read completes.
01272   virtual void complete (size_t bytes_transferred,
01273                          int success,
01274                          const void *completion_key,
01275                          u_long error);
01276 
01277   /// Destructor.
01278   virtual ~ACE_POSIX_Asynch_Read_Dgram_Result (void);
01279 
01280   /// Bytes requested when the asynchronous read was initiated.
01281   size_t bytes_to_read_;
01282 
01283   /// Message block for reading the data into.
01284   ACE_Message_Block *message_block_;
01285 
01286   /// The address of where the packet came from
01287   ACE_Addr *remote_address_;
01288 
01289   int addr_len_;
01290 
01291   /// The flags used in the read
01292   int flags_;
01293 
01294   /// I/O handle used for reading.
01295   ACE_HANDLE handle_;
01296 
01297 };
01298 
01299 
01300 #if defined (__ACE_INLINE__)
01301 #include "ace/POSIX_Asynch_IO.i"
01302 #endif /* __ACE_INLINE__ */
01303 
01304 #endif /* ACE_HAS_AIO_CALLS */
01305 #endif /* ACE_POSIX_ASYNCH_IO_H */

Generated on Mon Jun 16 11:20:51 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002