dep/ACE_wrappers/ace/Proactor.h

   1 // -*- C++ -*-
   2
   3 //=============================================================================
   4 /**
   5  *  @file    Proactor.h
   6  *
   7  *  $Id: Proactor.h 80826 2008-03-04 14:51:23Z wotte $
   8  *
   9  *  @author Irfan Pyarali <irfan@cs.wustl.edu>
  10  *  @author Tim Harrison <harrison@cs.wustl.edu>
  11  *  @author Alexander Babu Arulanthu <alex@cs.wustl.edu>
  12  *  @author Alexander Libman <alibman@ihug.com.au>
  13  */
  14 //=============================================================================
  15
  16 #ifndef ACE_PROACTOR_H
  17 #define ACE_PROACTOR_H
  18
  19 #include /**/ "ace/pre.h"
  20
  21 #include /**/ "ace/config-all.h"
  22 #include /**/ "ace/ACE_export.h"
  23
  24 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  25 #pragma once
  26 #endif /* ACE_LACKS_PRAGMA_ONCE */
  27
  28 #if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS)
  29 // This only works on Win32 platforms and on Unix platforms supporting
  30 // POSIX aio calls.
  31
  32 #  include "ace/Asynch_IO.h"
  33 #  include "ace/Asynch_IO_Impl.h"
  34 #  include "ace/Thread_Manager.h"
  35 #  include "ace/Timer_Queue.h"
  36 #  include "ace/Timer_List.h"
  37 #  include "ace/Timer_Heap.h"
  38 #  include "ace/Timer_Wheel.h"
  39
  40 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  41
  42 // Forward declarations.
  43 class ACE_Proactor_Impl;
  44 class ACE_Proactor_Timer_Handler;
  45
  46 /**
  47  * @class ACE_Proactor_Handle_Timeout_Upcall
  48  *
  49  * @brief Functor for ACE_Timer_Queue.
  50  *
  51  * This class implements the functor required by the Timer
  52  * Queue to call <handle_timeout> on ACE_Handlers.
  53  */
  54 class ACE_Proactor_Handle_Timeout_Upcall
  55 {
  56
  57   /// Type def for the timer queue.
  58   typedef ACE_Timer_Queue_T<ACE_Handler *,
  59                             ACE_Proactor_Handle_Timeout_Upcall,
  60                             ACE_SYNCH_RECURSIVE_MUTEX>
  61   TIMER_QUEUE;
  62
  63   /// The main Proactor class has special permissions.
  64   friend class ACE_Proactor;
  65
  66 public:
  67   /// Constructor.
  68   ACE_Proactor_Handle_Timeout_Upcall (void);
  69
  70   /// This method is called when a timer is registered.
  71   int registration (TIMER_QUEUE &timer_queue,
  72                     ACE_Handler *handler,
  73                     const void *arg);
  74
  75   /// This method is called before the timer expires.
  76   int preinvoke (TIMER_QUEUE &timer_queue,
  77                  ACE_Handler *handler,
  78                  const void *arg,
  79                  int recurring_timer,
  80                  const ACE_Time_Value &cur_time,
  81                  const void *&upcall_act);
  82
  83   /// This method is called when the timer expires.
  84   int timeout (TIMER_QUEUE &timer_queue,
  85                ACE_Handler *handler,
  86                const void *arg,
  87                int recurring_timer,
  88                const ACE_Time_Value &cur_time);
  89
  90   /// This method is called after the timer expires.
  91   int postinvoke (TIMER_QUEUE &timer_queue,
  92                   ACE_Handler *handler,
  93                   const void *arg,
  94                   int recurring_timer,
  95                   const ACE_Time_Value &cur_time,
  96                   const void *upcall_act);
  97
  98   /// This method is called when a handler is canceled.
  99   int cancel_type (TIMER_QUEUE &timer_queue,
 100                    ACE_Handler *handler,
 101                    int dont_call_handle_close,
 102                    int &requires_reference_counting);
 103
 104   /// This method is called when a timer is canceled.
 105   int cancel_timer (TIMER_QUEUE &timer_queue,
 106                     ACE_Handler *handler,
 107                     int dont_call_handle_close,
 108                     int requires_reference_counting);
 109
 110   /// This method is called when the timer queue is destroyed and the
 111   /// timer is still contained in it.
 112   int deletion (TIMER_QUEUE &timer_queue,
 113                 ACE_Handler *handler,
 114                 const void *arg);
 115
 116 protected:
 117   /// Set the proactor. This will fail, if one is already set!
 118   int proactor (ACE_Proactor &proactor);
 119
 120   /// Handle to the proactor. This is needed for posting a timer result
 121   /// to the Proactor's completion queue.
 122   ACE_Proactor *proactor_;
 123 };
 124
 125 /**
 126  * @class ACE_Proactor
 127  *
 128  * @brief A manager for asynchronous event demultiplexing.
 129  *
 130  * See the Proactor pattern description at
 131  * http://www.cs.wustl.edu/~schmidt/proactor.ps.gz for more
 132  * details.
 133  */
 134 class ACE_Export ACE_Proactor
 135 {
 136   // = Here are the private typedefs that the ACE_Proactor uses.
 137
 138   typedef ACE_Timer_Queue_Iterator_T<ACE_Handler *,
 139     ACE_Proactor_Handle_Timeout_Upcall,
 140     ACE_SYNCH_RECURSIVE_MUTEX>
 141   TIMER_QUEUE_ITERATOR;
 142   typedef ACE_Timer_List_T<ACE_Handler *,
 143     ACE_Proactor_Handle_Timeout_Upcall,
 144     ACE_SYNCH_RECURSIVE_MUTEX>
 145   TIMER_LIST;
 146   typedef ACE_Timer_List_Iterator_T<ACE_Handler *,
 147     ACE_Proactor_Handle_Timeout_Upcall,
 148     ACE_SYNCH_RECURSIVE_MUTEX>
 149   TIMER_LIST_ITERATOR;
 150   typedef ACE_Timer_Heap_T<ACE_Handler *,
 151     ACE_Proactor_Handle_Timeout_Upcall,
 152     ACE_SYNCH_RECURSIVE_MUTEX>
 153   TIMER_HEAP;
 154   typedef ACE_Timer_Heap_Iterator_T<ACE_Handler *,
 155     ACE_Proactor_Handle_Timeout_Upcall,
 156     ACE_SYNCH_RECURSIVE_MUTEX>
 157   TIMER_HEAP_ITERATOR;
 158   typedef ACE_Timer_Wheel_T<ACE_Handler *,
 159     ACE_Proactor_Handle_Timeout_Upcall,
 160     ACE_SYNCH_RECURSIVE_MUTEX>
 161   TIMER_WHEEL;
 162   typedef ACE_Timer_Wheel_Iterator_T<ACE_Handler *,
 163     ACE_Proactor_Handle_Timeout_Upcall,
 164     ACE_SYNCH_RECURSIVE_MUTEX>
 165   TIMER_WHEEL_ITERATOR;
 166
 167   // = Friendship.
 168
 169   /// Timer handler runs a thread and manages the timers, on behalf of
 170   /// the Proactor.
 171   friend class ACE_Proactor_Timer_Handler;
 172
 173 public:
 174   /// Public type.
 175   typedef ACE_Timer_Queue_T<ACE_Handler *,
 176     ACE_Proactor_Handle_Timeout_Upcall,
 177     ACE_SYNCH_RECURSIVE_MUTEX>
 178   TIMER_QUEUE;
 179
 180   /**
 181    * Constructor. If @a implementation is 0, the correct implementation
 182    * object will be created. @a delete_implementation flag determines
 183    * whether the implementation object should be deleted by the
 184    * Proactor or not. If @a tq is 0, a new TIMER_QUEUE is created.
 185    */
 186   ACE_Proactor (ACE_Proactor_Impl *implementation = 0,
 187                 bool delete_implementation = false,
 188                 TIMER_QUEUE *tq = 0);
 189
 190   /// Destruction.
 191   ~ACE_Proactor (void);
 192
 193   /// Get pointer to a process-wide ACE_Proactor.  @a threads should
 194   /// be part of another method.
 195   static ACE_Proactor *instance (size_t threads = 0);
 196
 197   /// Set pointer to a process-wide ACE_Proactor and return existing
 198   /// pointer.
 199   static ACE_Proactor *instance (ACE_Proactor * proactor,
 200                                  bool delete_proactor = false);
 201
 202   /// Delete the dynamically allocated Singleton.
 203   static void close_singleton (void);
 204
 205   /// Cleanup method, used by the ACE_Object_Manager to destroy the
 206   /// singleton.
 207   static void cleanup (void *instance, void *arg);
 208
 209   /// Name of dll in which the singleton instance lives.
 210   static const ACE_TCHAR *dll_name (void);
 211
 212   /// Name of component--ACE_Proactor in this case.
 213   static const ACE_TCHAR *name (void);
 214
 215   // = Proactor event loop management methods.
 216
 217   /// Run the event loop until the <ACE_Proactor::handle_events> method
 218   /// returns -1 or the <end_event_loop> method is invoked.
 219   static int run_event_loop (void);
 220
 221   /**
 222    * Run the event loop until the <ACE_Proactor::handle_events> method
 223    * returns -1, the <end_event_loop> method is invoked, or the
 224    * ACE_Time_Value expires, in which case 0 is returned.
 225    */
 226   static int run_event_loop (ACE_Time_Value &tv);
 227
 228   /**
 229    * Instruct the <ACE_Proactor::instance> to terminate its event
 230    * loop.
 231    * This method wakes up all the threads blocked on waiting for
 232    * completions and end the event loop.
 233    */
 234   static int end_event_loop (void);
 235
 236   /**
 237    * Resets the <ACE_Proactor::end_event_loop_> static so that the
 238    * <run_event_loop> method can be restarted.
 239    */
 240   static int reset_event_loop (void);
 241
 242   /**
 243    * The singleton proactor is used by the ACE_Service_Config.
 244    * Therefore, we must check for the reconfiguration request and
 245    * handle it after handling an event.
 246    */
 247   static int check_reconfiguration (ACE_Proactor *);
 248
 249   /// Report if the <ACE_Proactor::instance> event loop is finished.
 250   static int event_loop_done (void);
 251
 252   /// Close the associated @c ACE_Proactor_Impl implementation object.
 253   /**
 254    * If @arg delete_implementation was specified to the @c open() method,
 255    * the implementation object is also deleted.
 256    */
 257   int close (void);
 258
 259    /**
 260    * You can add a hook to various run_event methods and the hook will
 261    * be called after handling every proactor event.  If this function
 262    * returns 0, proactor_run_event_loop will check for the return value of
 263    * handle_events.  If it is -1, the the proactor_run_event_loop will return
 264    * (pre-maturely.)
 265    */
 266   typedef int (*PROACTOR_EVENT_HOOK)(ACE_Proactor *);
 267
 268   // These methods work with an instance of a proactor.
 269   /**
 270    * Run the event loop until the
 271    * <ACE_Proactor::handle_events>
 272    * method returns -1 or the <end_proactor_event_loop> method is invoked.
 273    */
 274   int proactor_run_event_loop (PROACTOR_EVENT_HOOK = 0);
 275
 276   /**
 277    * Run the event loop until the <ACE_Proactor::handle_events>
 278    * method returns -1, the
 279    * <end_proactor_event_loop> method is invoked,
 280    * or the ACE_Time_Value
 281    * expires, in which case a 0 is returned.
 282    */
 283   int proactor_run_event_loop (ACE_Time_Value &tv,
 284                                PROACTOR_EVENT_HOOK = 0);
 285
 286   /**
 287    * Instruct the ACE_Proactor to terminate its event loop
 288    * and notifies the ACE_Proactor so that it can wake up
 289    * and close down gracefully.
 290    */
 291   int proactor_end_event_loop (void);
 292
 293   /// Report if the ACE_Proactor event loop is finished.
 294   int proactor_event_loop_done (void);
 295
 296   /// Resets the <ACE_Proactor::end_event_loop_> static so that the
 297   /// <run_event_loop> method can be restarted.
 298   int proactor_reset_event_loop (void);
 299
 300
 301   /// This method adds the @a handle to the I/O completion port. This
 302   /// function is a no-op function for Unix systems and returns 0;
 303   int register_handle (ACE_HANDLE handle,
 304                        const void *completion_key);
 305
 306   // = Timer management.
 307   /**
 308    * Schedule a @a handler that will expire after <time>.  If it
 309    * expires then @a act is passed in as the value to the @a handler's
 310    * <handle_timeout> callback method.  This method returns a
 311    * <timer_id>. This <timer_id> can be used to cancel a timer before
 312    * it expires.  The cancellation ensures that <timer_ids> are unique
 313    * up to values of greater than 2 billion timers.  As long as timers
 314    * don't stay around longer than this there should be no problems
 315    * with accidentally deleting the wrong timer.  Returns -1 on
 316    * failure (which is guaranteed never to be a valid <timer_id>).
 317    */
 318   long schedule_timer (ACE_Handler &handler,
 319                        const void *act,
 320                        const ACE_Time_Value &time);
 321
 322   long schedule_repeating_timer (ACE_Handler &handler,
 323                                  const void *act,
 324                                  const ACE_Time_Value &interval);
 325
 326   // Same as above except @a interval it is used to reschedule the
 327   // @a handler automatically.
 328
 329   /// This combines the above two methods into one. Mostly for backward
 330   /// compatibility.
 331   long schedule_timer (ACE_Handler &handler,
 332                        const void *act,
 333                        const ACE_Time_Value &time,
 334                        const ACE_Time_Value &interval);
 335
 336   /// Cancel all timers associated with this @a handler.  Returns number
 337   /// of timers cancelled.
 338   int cancel_timer (ACE_Handler &handler,
 339                     int dont_call_handle_close = 1);
 340
 341   /**
 342    * Cancel the single <ACE_Handler> that matches the @a timer_id value
 343    * (which was returned from the <schedule> method).  If @a act is
 344    * non-NULL then it will be set to point to the ``magic cookie''
 345    * argument passed in when the <Handler> was registered.  This makes
 346    * it possible to free up the memory and avoid memory leaks.
 347    * Returns 1 if cancellation succeeded and 0 if the @a timer_id
 348    * wasn't found.
 349    */
 350   int cancel_timer (long timer_id,
 351                     const void **act = 0,
 352                     int dont_call_handle_close = 1);
 353
 354   /**
 355    * Dispatch a single set of events, waiting up to a specified time limit
 356    * if necessary.
 357    * @param wait_time the time to wait for an event to occur. This is
 358    * a relative time. On successful return, the time is updated to
 359    * reflect the amount of time spent waiting for event(s) to occur.
 360    * @return Returns 0 if no events occur before the wait_time expires.
 361    * Returns 1 when a completion is dispatched. On error, returns -1
 362    * and sets errno accordingly.
 363    */
 364   int handle_events (ACE_Time_Value &wait_time);
 365
 366   /**
 367    * Block indefinitely until at least one event is dispatched.
 368    * @return Returns 1 when a completion is dispatched. On error, returns -1
 369    * and sets errno accordingly.
 370    */
 371   int handle_events (void);
 372
 373   /// Add wakeup dispatch threads (reinit).
 374   int wake_up_dispatch_threads (void);
 375
 376   /// Close all dispatch threads.
 377   int close_dispatch_threads (int wait);
 378
 379   /// Get number of thread used as a parameter to CreatIoCompletionPort.
 380   size_t number_of_threads (void) const;
 381
 382   /// Set number of thread used as a parameter to CreatIoCompletionPort.
 383   void number_of_threads (size_t threads);
 384
 385   /// Get timer queue.
 386   TIMER_QUEUE *timer_queue (void) const;
 387
 388   /// Set timer queue.
 389   void timer_queue (TIMER_QUEUE *timer_queue);
 390
 391   /**
 392    * Get the event handle.
 393    * It is a no-op in POSIX platforms and it returns
 394    * ACE_INVALID_HANDLE.
 395    */
 396   ACE_HANDLE get_handle (void) const;
 397
 398   /// Get the implementation class.
 399   ACE_Proactor_Impl *implementation (void) const;
 400
 401   // = Factory methods for the operations
 402
 403   // Note that the user does not have to use or know about these
 404   // methods.
 405
 406   /// Create the correct implementation class for doing
 407   /// Asynch_Read_Stream.
 408   ACE_Asynch_Read_Stream_Impl *create_asynch_read_stream (void);
 409
 410   /// Create the correct implementation class for doing
 411   /// Asynch_Write_Stream.
 412   ACE_Asynch_Write_Stream_Impl *create_asynch_write_stream (void);
 413
 414   /// Create the correct implementation class for doing
 415   /// Asynch_Read_File.
 416   ACE_Asynch_Read_File_Impl *create_asynch_read_file (void);
 417
 418   /// Create the correct implementation class for doing
 419   /// Asynch_Write_File.
 420   ACE_Asynch_Write_File_Impl *create_asynch_write_file (void);
 421
 422   /// Create the correct implementation class for doing Asynch_Accept.
 423   ACE_Asynch_Accept_Impl *create_asynch_accept (void);
 424
 425   /// Create the correct implementation class for doing Asynch_Connect.
 426   ACE_Asynch_Connect_Impl *create_asynch_connect (void);
 427
 428   /// Create the correct implementation class for doing
 429   /// Asynch_Transmit_File.
 430   ACE_Asynch_Transmit_File_Impl *create_asynch_transmit_file (void);
 431
 432   /// Create the correct implementation class for doing
 433   /// Asynch_Read_Dgram.
 434   ACE_Asynch_Read_Dgram_Impl *create_asynch_read_dgram (void);
 435
 436   /// Create the correct implementation class for doing
 437   /// Asynch_Write_Dgram.
 438   ACE_Asynch_Write_Dgram_Impl *create_asynch_write_dgram (void);
 439
 440   // = Factory methods for the results
 441
 442   // Note that the user does not have to use or know about these
 443   // methods unless they want to "fake" results.
 444
 445   /// Create the correct implementation class for
 446   /// ACE_Asynch_Read_Stream::Result class.
 447   ACE_Asynch_Read_Stream_Result_Impl *
 448     create_asynch_read_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
 449                                       ACE_HANDLE handle,
 450                                       ACE_Message_Block &message_block,
 451                                       u_long bytes_to_read,
 452                                       const void* act,
 453                                       ACE_HANDLE event = ACE_INVALID_HANDLE,
 454                                       int priority = 0,
 455                                       int signal_number = ACE_SIGRTMIN);
 456
 457   /// Create the correct implementation class for
 458   /// ACE_Asynch_Write_Stream::Result.
 459   ACE_Asynch_Write_Stream_Result_Impl *
 460     create_asynch_write_stream_result (ACE_Handler::Proxy_Ptr &handler_proxy,
 461                                        ACE_HANDLE handle,
 462                                        ACE_Message_Block &message_block,
 463                                        u_long bytes_to_write,
 464                                        const void* act,
 465                                        ACE_HANDLE event = ACE_INVALID_HANDLE,
 466                                        int priority = 0,
 467                                        int signal_number = ACE_SIGRTMIN);
 468
 469   /// Create the correct implementation class for
 470   /// ACE_Asynch_Read_File::Result.
 471   ACE_Asynch_Read_File_Result_Impl *
 472     create_asynch_read_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
 473                                     ACE_HANDLE handle,
 474                                     ACE_Message_Block &message_block,
 475                                     u_long bytes_to_read,
 476                                     const void* act,
 477                                     u_long offset,
 478                                     u_long offset_high,
 479                                     ACE_HANDLE event = ACE_INVALID_HANDLE,
 480                                     int priority = 0,
 481                                     int signal_number = ACE_SIGRTMIN);
 482
 483   /// Create the correct implementation class for
 484   /// ACE_Asynch_Write_File::Result.
 485   ACE_Asynch_Write_File_Result_Impl *
 486     create_asynch_write_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
 487                                      ACE_HANDLE handle,
 488                                      ACE_Message_Block &message_block,
 489                                      u_long bytes_to_write,
 490                                      const void* act,
 491                                      u_long offset,
 492                                      u_long offset_high,
 493                                      ACE_HANDLE event = ACE_INVALID_HANDLE,
 494                                      int priority = 0,
 495                                      int signal_number = ACE_SIGRTMIN);
 496
 497   /// Create the correct implementation class for
 498   /// ACE_Asynch_Read_Dgram::Result.
 499   ACE_Asynch_Read_Dgram_Result_Impl *
 500     create_asynch_read_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
 501                                      ACE_HANDLE handle,
 502                                      ACE_Message_Block *message_block,
 503                                      size_t bytes_to_read,
 504                                      int flags,
 505                                      int protocol_family,
 506                                      const void* act,
 507                                      ACE_HANDLE event = ACE_INVALID_HANDLE,
 508                                      int priority = 0,
 509                                      int signal_number = ACE_SIGRTMIN);
 510
 511   /// Create the correct implementation class for
 512   /// ACE_Asynch_Write_Dgram::Result.
 513   ACE_Asynch_Write_Dgram_Result_Impl *
 514     create_asynch_write_dgram_result (ACE_Handler::Proxy_Ptr &handler_proxy,
 515                                       ACE_HANDLE handle,
 516                                       ACE_Message_Block *message_block,
 517                                       size_t bytes_to_write,
 518                                       int flags,
 519                                       const void* act,
 520                                       ACE_HANDLE event = ACE_INVALID_HANDLE,
 521                                       int priority = 0,
 522                                       int signal_number = ACE_SIGRTMIN);
 523
 524   /// Create the correct implementation class for ACE_Asynch_Accept::Result.
 525   ACE_Asynch_Accept_Result_Impl *
 526     create_asynch_accept_result (ACE_Handler::Proxy_Ptr &handler_proxy,
 527                                  ACE_HANDLE listen_handle,
 528                                  ACE_HANDLE accept_handle,
 529                                  ACE_Message_Block &message_block,
 530                                  u_long bytes_to_read,
 531                                  const void* act,
 532                                  ACE_HANDLE event = ACE_INVALID_HANDLE,
 533                                  int priority = 0,
 534                                  int signal_number = ACE_SIGRTMIN);
 535
 536   /// Create the correct implementation class for ACE_Asynch_Connect::Result
 537   ACE_Asynch_Connect_Result_Impl *
 538     create_asynch_connect_result (ACE_Handler::Proxy_Ptr &handler_proxy,
 539                                   ACE_HANDLE  connect_handle,
 540                                   const void* act,
 541                                   ACE_HANDLE event = ACE_INVALID_HANDLE,
 542                                   int priority = 0,
 543                                   int signal_number = ACE_SIGRTMIN);
 544
 545   /// Create the correct implementation class for
 546   /// ACE_Asynch_Transmit_File::Result.
 547   ACE_Asynch_Transmit_File_Result_Impl *
 548     create_asynch_transmit_file_result (ACE_Handler::Proxy_Ptr &handler_proxy,
 549                                         ACE_HANDLE socket,
 550                                         ACE_HANDLE file,
 551                                         ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer,
 552                                         u_long bytes_to_write,
 553                                         u_long offset,
 554                                         u_long offset_high,
 555                                         u_long bytes_per_send,
 556                                         u_long flags,
 557                                         const void *act,
 558                                         ACE_HANDLE event = ACE_INVALID_HANDLE,
 559                                         int priority = 0,
 560                                         int signal_number = ACE_SIGRTMIN);
 561
 562   /**
 563    * Create a timer result object which can be used with the Timer
 564    * mechanism of the Proactor.
 565    * If @a signal_number is -1, <POSIX_SIG_Proactor> will create a
 566    * Timer object with a meaningful signal number, choosing the
 567    * largest signal number from the signal mask of the Proactor.
 568    */
 569   ACE_Asynch_Result_Impl *
 570     create_asynch_timer (ACE_Handler::Proxy_Ptr &handler_proxy,
 571                          const void *act,
 572                          const ACE_Time_Value &tv,
 573                          ACE_HANDLE event = ACE_INVALID_HANDLE,
 574                          int priority = 0,
 575                          int signal_number = ACE_SIGRTMIN);
 576
 577 protected:
 578
 579   /**
 580    * Post <how_many> completions to the completion port so that all
 581    * threads can wake up. This is used in conjunction with the
 582    * <run_event_loop>.
 583    */
 584   static int post_wakeup_completions (int how_many);
 585
 586   /**
 587    * Post <how_many> completions to the completion port so that all
 588    * threads can wake up. This is used in conjunction with the
 589    * <proactor_run_event_loop>.
 590    */
 591   int proactor_post_wakeup_completions (int how_many);
 592
 593   /// Set the implementation class.
 594   void implementation (ACE_Proactor_Impl *implementation);
 595
 596   /// Delegation/implementation class that all methods will be
 597   /// forwarded to.
 598   ACE_Proactor_Impl *implementation_;
 599
 600   /// Flag used to indicate whether we are responsible for cleaning up
 601   /// the implementation instance.
 602   bool delete_implementation_;
 603
 604   /// Pointer to a process-wide ACE_Proactor.
 605   static ACE_Proactor *proactor_;
 606
 607   /// Must delete the <proactor_> if true.
 608   static bool delete_proactor_;
 609
 610   /// Handles timeout events.
 611   ACE_Proactor_Timer_Handler *timer_handler_;
 612
 613   /// This will manage the thread in the Timer_Handler.
 614   ACE_Thread_Manager thr_mgr_;
 615
 616   /// Timer Queue.
 617   TIMER_QUEUE *timer_queue_;
 618
 619   /// Flag on whether to delete the timer queue.
 620   int delete_timer_queue_;
 621
 622   /// Terminate the proactor event loop.
 623   sig_atomic_t end_event_loop_;
 624
 625   /// Number of threads in the event loop.
 626   sig_atomic_t event_loop_thread_count_;
 627
 628   /// Mutex to protect work with lists.
 629   ACE_SYNCH_MUTEX mutex_;
 630
 631
 632 private:
 633   /// Deny access since member-wise won't work...
 634   ACE_Proactor (const ACE_Proactor &);
 635   ACE_Proactor &operator= (const ACE_Proactor &);
 636 };
 637
 638 ACE_END_VERSIONED_NAMESPACE_DECL
 639
 640 #  if defined (__ACE_INLINE__)
 641 #    include "ace/Proactor.inl"
 642 #  endif /* __ACE_INLINE__ */
 643
 644 #else /* NOT WIN32 or POSIX with AIO features. */
 645
 646 #  include "ace/os_include/os_stddef.h"
 647 #  include "ace/os_include/os_signal.h"
 648
 649 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
 650
 651 class ACE_Time_Value;
 652
 653 class ACE_Export ACE_Proactor
 654 {
 655 public:
 656   class Timer_Queue {};
 657   ACE_Proactor (size_t /* number_of_threads */ = 0,
 658                 Timer_Queue * /* tq */ = 0) {}
 659   ~ACE_Proactor (void) {}
 660   int handle_events (void) { return -1; }
 661   int handle_events (ACE_Time_Value &) { return -1; }
 662
 663   /// Placeholder to enable compilation on non-Win32 platforms
 664   static ACE_Proactor *instance (size_t threads = 0);
 665
 666   /// Placeholder to enable compilation on non-Win32 platforms
 667   static ACE_Proactor *instance (ACE_Proactor *);
 668
 669   /// Placeholder to enable compilation on non-Win32 platforms
 670   static void close_singleton (void);
 671
 672   /// Placeholder to enable compilation on non-Win32 platforms
 673   static int run_event_loop (void);
 674
 675   /// Placeholder to enable compilation on non-Win32 platforms
 676   static int run_event_loop (ACE_Time_Value &tv);
 677
 678   /// Placeholder to enable compilation on non-Win32 platforms
 679   static int end_event_loop (void);
 680
 681   /// Placeholder to enable compilation on non-Win32 platforms
 682   static sig_atomic_t event_loop_done (void);
 683 };
 684
 685 ACE_END_VERSIONED_NAMESPACE_DECL
 686
 687 #endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */
 688
 689 #include /**/ "ace/post.h"
 690
 691 #endif /* ACE_PROACTOR_H */