ACE/ace/Reactor.inl

   1 // -*- C++ -*-
   2 #include "ace/Reactor_Impl.h"
   3
   4 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   5
   6 // Run the event loop until the <ACE_Reactor::handle_events> method
   7 // returns -1 or the <end_event_loop> method is invoked.
   8 ACE_INLINE int
   9 ACE_Reactor::run_event_loop ()
  10 {
  11   ACE_TRACE ("ACE_Reactor::run_event_loop");
  12   ACE_Reactor *r = ACE_Reactor::instance ();
  13
  14   if (r == 0)
  15     return -1;
  16
  17   return r->run_reactor_event_loop (ACE_Reactor::check_reconfiguration);
  18 }
  19
  20 // Run the event loop until the <ACE_Reactor::handle_events>
  21 // method returns -1, the <end_event_loop> method
  22 // is invoked, or the <ACE_Time_Value> expires.
  23
  24 ACE_INLINE int
  25 ACE_Reactor::run_event_loop (ACE_Time_Value &tv)
  26 {
  27   ACE_TRACE ("ACE_Reactor::run_event_loop");
  28   ACE_Reactor *r = ACE_Reactor::instance ();
  29
  30   if (r == 0)
  31     return -1;
  32
  33   return r->run_reactor_event_loop
  34     (tv, ACE_Reactor::check_reconfiguration);
  35 }
  36
  37 // Run the event loop until the <ACE_Reactor::alertable_handle_events> method
  38 // returns -1 or the <end_event_loop> method is invoked.
  39
  40 ACE_INLINE int
  41 ACE_Reactor::run_alertable_event_loop ()
  42 {
  43   ACE_TRACE ("ACE_Reactor::run_alertable_event_loop");
  44   ACE_Reactor *r = ACE_Reactor::instance ();
  45
  46   if (r == 0)
  47     return -1;
  48
  49   return r->run_alertable_reactor_event_loop (ACE_Reactor::check_reconfiguration);
  50 }
  51
  52 // Run the event loop until the <ACE_Reactor::alertable_handle_events>
  53 // method returns -1, the <end_event_loop> method
  54 // is invoked, or the <ACE_Time_Value> expires.
  55
  56 ACE_INLINE int
  57 ACE_Reactor::run_alertable_event_loop (ACE_Time_Value &tv)
  58 {
  59   ACE_TRACE ("ACE_Reactor::run_alertable_event_loop");
  60   ACE_Reactor *r = ACE_Reactor::instance ();
  61
  62   if (r == 0)
  63     return -1;
  64
  65   return r->run_alertable_reactor_event_loop
  66     (tv, ACE_Reactor::check_reconfiguration);
  67 }
  68
  69 ACE_INLINE void
  70 ACE_Reactor::reset_event_loop ()
  71 {
  72   ACE_TRACE ("ACE_Reactor::reset_event_loop");
  73
  74   ACE_Reactor::instance ()->reset_reactor_event_loop ();
  75 }
  76
  77 ACE_INLINE int
  78 ACE_Reactor::end_event_loop ()
  79 {
  80   ACE_TRACE ("ACE_Reactor::end_event_loop");
  81   ACE_Reactor::instance ()->end_reactor_event_loop ();
  82
  83   return 0;
  84 }
  85
  86 ACE_INLINE int
  87 ACE_Reactor::event_loop_done ()
  88 {
  89   ACE_TRACE ("ACE_Reactor::event_loop_done");
  90   return ACE_Reactor::instance ()->reactor_event_loop_done ();
  91 }
  92
  93 ACE_INLINE int
  94 ACE_Reactor::end_reactor_event_loop ()
  95 {
  96   ACE_TRACE ("ACE_Reactor::end_reactor_event_loop");
  97
  98   this->implementation_->deactivate (1);
  99
 100   return 0;
 101 }
 102
 103 ACE_INLINE void
 104 ACE_Reactor::reset_reactor_event_loop ()
 105 {
 106   ACE_TRACE ("ACE_Reactor::reset_reactor_event_loop");
 107
 108   this->implementation_->deactivate (0);
 109 }
 110
 111 ACE_INLINE int
 112 ACE_Reactor::resumable_handler ()
 113 {
 114   return this->implementation ()->resumable_handler ();
 115 }
 116
 117 ACE_INLINE ACE_Reactor_Impl *
 118 ACE_Reactor::implementation () const
 119 {
 120   return this->implementation_;
 121 }
 122
 123 ACE_INLINE void
 124 ACE_Reactor::implementation (ACE_Reactor_Impl *impl)
 125 {
 126   this->implementation_ = impl;
 127 }
 128
 129 ACE_INLINE int
 130 ACE_Reactor::current_info (ACE_HANDLE handle, size_t &size)
 131 {
 132   return this->implementation ()->current_info (handle, size);
 133 }
 134
 135 ACE_INLINE int
 136 ACE_Reactor::open (size_t size,
 137                    bool restart,
 138                    ACE_Sig_Handler *signal_handler,
 139                    ACE_Timer_Queue *timer_queue)
 140 {
 141   return this->implementation ()->open (size,
 142                                         restart,
 143                                         signal_handler,
 144                                         timer_queue);
 145 }
 146 ACE_INLINE int
 147 ACE_Reactor::set_sig_handler (ACE_Sig_Handler *signal_handler)
 148 {
 149   return this->implementation ()->set_sig_handler (signal_handler);
 150 }
 151
 152 ACE_INLINE int
 153 ACE_Reactor::timer_queue (ACE_Timer_Queue *tq)
 154 {
 155   return this->implementation ()->timer_queue (tq);
 156 }
 157
 158 ACE_INLINE ACE_Timer_Queue *
 159 ACE_Reactor::timer_queue () const
 160 {
 161   return this->implementation ()->timer_queue ();
 162 }
 163
 164 ACE_INLINE int
 165 ACE_Reactor::close ()
 166 {
 167   return this->implementation ()->close ();
 168 }
 169
 170 ACE_INLINE int
 171 ACE_Reactor::work_pending (const ACE_Time_Value &max_wait_time)
 172 {
 173   return this->implementation ()->work_pending (max_wait_time);
 174 }
 175
 176 ACE_INLINE int
 177 ACE_Reactor::handle_events (ACE_Time_Value *max_wait_time)
 178 {
 179   return this->implementation ()->handle_events (max_wait_time);
 180 }
 181
 182 ACE_INLINE int
 183 ACE_Reactor::alertable_handle_events (ACE_Time_Value *max_wait_time)
 184 {
 185   return this->implementation ()->alertable_handle_events (max_wait_time);
 186 }
 187
 188 ACE_INLINE int
 189 ACE_Reactor::handle_events (ACE_Time_Value &max_wait_time)
 190 {
 191   return this->implementation ()->handle_events (max_wait_time);
 192 }
 193
 194 ACE_INLINE int
 195 ACE_Reactor::alertable_handle_events (ACE_Time_Value &max_wait_time)
 196 {
 197   return this->implementation ()->alertable_handle_events (max_wait_time);
 198 }
 199
 200 ACE_INLINE int
 201 ACE_Reactor::register_handler (int signum,
 202                                ACE_Event_Handler *new_sh,
 203                                ACE_Sig_Action *new_disp,
 204                                ACE_Event_Handler **old_sh,
 205                                ACE_Sig_Action *old_disp)
 206 {
 207   return this->implementation ()->register_handler (signum,
 208                                                     new_sh,
 209                                                     new_disp,
 210                                                     old_sh,
 211                                                     old_disp);
 212 }
 213
 214 ACE_INLINE int
 215 ACE_Reactor::register_handler (const ACE_Sig_Set &sigset,
 216                                ACE_Event_Handler *new_sh,
 217                                ACE_Sig_Action *new_disp)
 218 {
 219   return this->implementation ()->register_handler (sigset,
 220                                                     new_sh,
 221                                                     new_disp);
 222 }
 223
 224 ACE_INLINE int
 225 ACE_Reactor::remove_handler (ACE_Event_Handler *event_handler,
 226                              ACE_Reactor_Mask mask)
 227 {
 228   return this->implementation ()->remove_handler (event_handler, mask);
 229 }
 230
 231 ACE_INLINE int
 232 ACE_Reactor::remove_handler (ACE_HANDLE handle,
 233                              ACE_Reactor_Mask mask)
 234 {
 235   return this->implementation ()->remove_handler (handle, mask);
 236 }
 237
 238 ACE_INLINE int
 239 ACE_Reactor::remove_handler (const ACE_Handle_Set &handle_set,
 240                              ACE_Reactor_Mask mask)
 241 {
 242   return this->implementation ()->remove_handler (handle_set, mask);
 243 }
 244
 245 ACE_INLINE int
 246 ACE_Reactor::remove_handler (int signum,
 247                              ACE_Sig_Action *new_disp,
 248                              ACE_Sig_Action *old_disp,
 249                              int sigkey)
 250 {
 251   return this->implementation ()->remove_handler (signum,
 252                                                   new_disp,
 253                                                   old_disp,
 254                                                   sigkey);
 255 }
 256
 257 ACE_INLINE int
 258 ACE_Reactor::remove_handler (const ACE_Sig_Set &sigset)
 259 {
 260   return this->implementation ()->remove_handler (sigset);
 261 }
 262
 263 ACE_INLINE int
 264 ACE_Reactor::suspend_handler (ACE_Event_Handler *event_handler)
 265 {
 266   return this->implementation ()->suspend_handler (event_handler);
 267 }
 268
 269 ACE_INLINE int
 270 ACE_Reactor::suspend_handler (ACE_HANDLE handle)
 271 {
 272   return this->implementation ()->suspend_handler (handle);
 273 }
 274
 275 ACE_INLINE int
 276 ACE_Reactor::suspend_handler (const ACE_Handle_Set &handles)
 277 {
 278   return this->implementation ()->suspend_handler (handles);
 279 }
 280
 281 ACE_INLINE int
 282 ACE_Reactor::suspend_handlers ()
 283 {
 284   return this->implementation ()->suspend_handlers ();
 285 }
 286
 287 ACE_INLINE int
 288 ACE_Reactor::resume_handler (ACE_Event_Handler *event_handler)
 289 {
 290   return this->implementation ()->resume_handler (event_handler);
 291 }
 292
 293 ACE_INLINE int
 294 ACE_Reactor::resume_handler (ACE_HANDLE handle)
 295 {
 296   return this->implementation ()->resume_handler (handle);
 297 }
 298
 299 ACE_INLINE int
 300 ACE_Reactor::resume_handler (const ACE_Handle_Set &handles)
 301 {
 302   return this->implementation ()->resume_handler (handles);
 303 }
 304
 305 ACE_INLINE int
 306 ACE_Reactor::resume_handlers ()
 307 {
 308   return this->implementation ()->resume_handlers ();
 309 }
 310
 311 ACE_INLINE int
 312 ACE_Reactor::schedule_wakeup (ACE_HANDLE handle,
 313                               ACE_Reactor_Mask masks_to_be_added)
 314 {
 315   return implementation ()->schedule_wakeup (handle, masks_to_be_added);
 316 }
 317
 318 ACE_INLINE int
 319 ACE_Reactor::cancel_wakeup (ACE_Event_Handler *event_handler,
 320                             ACE_Reactor_Mask masks_to_be_cleared)
 321 {
 322   return this->implementation ()->cancel_wakeup (event_handler,
 323                                                  masks_to_be_cleared);
 324 }
 325
 326 ACE_INLINE int
 327 ACE_Reactor::cancel_wakeup (ACE_HANDLE handle,
 328                             ACE_Reactor_Mask masks_to_be_cleared)
 329 {
 330   return this->implementation ()->cancel_wakeup (handle,
 331                                                  masks_to_be_cleared);
 332 }
 333
 334 ACE_INLINE void
 335 ACE_Reactor::max_notify_iterations (int iterations)
 336 {
 337   this->implementation ()->max_notify_iterations (iterations);
 338 }
 339
 340 ACE_INLINE int
 341 ACE_Reactor::max_notify_iterations ()
 342 {
 343   return this->implementation ()->max_notify_iterations ();
 344 }
 345
 346 ACE_INLINE int
 347 ACE_Reactor::purge_pending_notifications (ACE_Event_Handler *eh,
 348                                           ACE_Reactor_Mask   mask)
 349 {
 350   return this->implementation ()->purge_pending_notifications (eh, mask);
 351 }
 352
 353 ACE_INLINE ACE_Event_Handler *
 354 ACE_Reactor::find_handler (ACE_HANDLE handle)
 355 {
 356   return this->implementation ()->find_handler (handle);
 357 }
 358
 359 ACE_INLINE int
 360 ACE_Reactor::handler (ACE_HANDLE handle,
 361                       ACE_Reactor_Mask mask,
 362                       ACE_Event_Handler **event_handler)
 363 {
 364   return this->implementation ()->handler (handle, mask, event_handler);
 365 }
 366
 367 ACE_INLINE int
 368 ACE_Reactor::handler (int signum,
 369                       ACE_Event_Handler **event_handler)
 370 {
 371   return this->implementation ()->handler (signum, event_handler);
 372 }
 373
 374 ACE_INLINE int
 375 ACE_Reactor::initialized ()
 376 {
 377   return this->implementation ()->initialized ();
 378 }
 379
 380 ACE_INLINE ACE_Lock &
 381 ACE_Reactor::lock ()
 382 {
 383   return this->implementation ()->lock ();
 384 }
 385
 386 ACE_INLINE void
 387 ACE_Reactor::wakeup_all_threads ()
 388 {
 389   this->implementation ()->wakeup_all_threads ();
 390 }
 391
 392 ACE_INLINE int
 393 ACE_Reactor::owner (ACE_thread_t new_owner, ACE_thread_t *old_owner)
 394 {
 395   return this->implementation ()->owner (new_owner,  old_owner);
 396 }
 397
 398 ACE_INLINE int
 399 ACE_Reactor::owner (ACE_thread_t *owner)
 400 {
 401   return this->implementation ()->owner (owner);
 402 }
 403
 404 ACE_INLINE bool
 405 ACE_Reactor::restart ()
 406 {
 407   return this->implementation ()->restart ();
 408 }
 409
 410 ACE_INLINE bool
 411 ACE_Reactor::restart (bool r)
 412 {
 413   return this->implementation ()->restart (r);
 414 }
 415
 416 ACE_INLINE void
 417 ACE_Reactor::requeue_position (int position)
 418 {
 419   this->implementation ()->requeue_position (position);
 420 }
 421
 422 ACE_INLINE int
 423 ACE_Reactor::requeue_position ()
 424 {
 425   return this->implementation ()->requeue_position ();
 426 }
 427
 428 ACE_INLINE int
 429 ACE_Reactor::mask_ops (ACE_Event_Handler *event_handler,
 430                        ACE_Reactor_Mask mask,
 431                        int ops)
 432 {
 433   return this->implementation ()->mask_ops (event_handler, mask, ops);
 434 }
 435
 436 ACE_INLINE int
 437 ACE_Reactor::mask_ops (ACE_HANDLE handle,
 438                        ACE_Reactor_Mask mask,
 439                        int ops)
 440 {
 441   return this->implementation ()->mask_ops (handle, mask, ops);
 442 }
 443
 444 ACE_INLINE int
 445 ACE_Reactor::ready_ops (ACE_Event_Handler *event_handler,
 446                         ACE_Reactor_Mask mask,
 447                         int ops)
 448 {
 449   return this->implementation ()->ready_ops (event_handler, mask, ops);
 450 }
 451
 452 ACE_INLINE int
 453 ACE_Reactor::ready_ops (ACE_HANDLE handle,
 454                         ACE_Reactor_Mask mask,
 455                         int ops)
 456 {
 457   return this->implementation ()->ready_ops (handle, mask, ops);
 458 }
 459
 460 ACE_INLINE int
 461 ACE_Reactor::reactor_event_loop_done ()
 462 {
 463   ACE_TRACE ("ACE_Reactor::reactor_event_loop_done");
 464   return this->implementation_->deactivated ();
 465 }
 466
 467 ACE_INLINE size_t
 468 ACE_Reactor::size () const
 469 {
 470   return this->implementation ()->size ();
 471 }
 472
 473 ACE_INLINE bool
 474 ACE_Reactor::uses_event_associations ()
 475 {
 476   return this->implementation ()->uses_event_associations ();
 477 }
 478
 479 ACE_INLINE void
 480 ACE_Reactor::dump () const
 481 {
 482 #if defined (ACE_HAS_DUMP)
 483   ACE_TRACE ("ACE_Reactor::dump");
 484
 485   implementation_->dump ();
 486 #endif /* ACE_HAS_DUMP */
 487 }
 488
 489 ACE_END_VERSIONED_NAMESPACE_DECL