00001
00002
00003 #ifndef ACE_STRATEGIES_T_CPP
00004 #define ACE_STRATEGIES_T_CPP
00005
00006 #include "ace/Strategies_T.h"
00007
00008 #if !defined (ACE_LACKS_PRAGMA_ONCE)
00009 # pragma once
00010 #endif
00011
00012 #include "ace/Service_Repository.h"
00013 #include "ace/Service_Types.h"
00014 #include "ace/Thread_Manager.h"
00015 #include "ace/WFMO_Reactor.h"
00016 #include "ace/ACE.h"
00017 #include "ace/OS_NS_dlfcn.h"
00018 #include "ace/OS_NS_string.h"
00019 #include "ace/OS_Errno.h"
00020 #include "ace/Svc_Handler.h"
00021 #if defined (ACE_OPENVMS)
00022 # include "ace/Lib_Find.h"
00023 #endif
00024
00025 #if !defined (__ACE_INLINE__)
00026 #include "ace/Strategies_T.inl"
00027 #endif
00028
00029 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00030
00031 template<class SVC_HANDLER>
00032 ACE_Recycling_Strategy<SVC_HANDLER>::~ACE_Recycling_Strategy (void)
00033 {
00034 }
00035
00036 template<class SVC_HANDLER> int
00037 ACE_Recycling_Strategy<SVC_HANDLER>::assign_recycler (SVC_HANDLER *svc_handler,
00038 ACE_Connection_Recycling_Strategy *recycler,
00039 const void *recycling_act)
00040 {
00041 svc_handler->recycler (recycler, recycling_act);
00042 return 0;
00043 }
00044
00045 template<class SVC_HANDLER> int
00046 ACE_Recycling_Strategy<SVC_HANDLER>::prepare_for_recycling (SVC_HANDLER *svc_handler)
00047 {
00048 return svc_handler->recycle ();
00049 }
00050
00051 template <class SVC_HANDLER>
00052 ACE_Singleton_Strategy<SVC_HANDLER>::~ACE_Singleton_Strategy (void)
00053 {
00054 ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::~ACE_Singleton_Strategy");
00055 if (this->delete_svc_handler_)
00056 delete this->svc_handler_;
00057 }
00058
00059
00060
00061
00062 template <class SVC_HANDLER> int
00063 ACE_Singleton_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh)
00064 {
00065 ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::make_svc_handler");
00066 sh = this->svc_handler_;
00067 return 0;
00068 }
00069
00070 template <class SVC_HANDLER> int
00071 ACE_Singleton_Strategy<SVC_HANDLER>::open (SVC_HANDLER *sh,
00072 ACE_Thread_Manager *)
00073 {
00074 ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::open");
00075
00076 if (this->delete_svc_handler_)
00077 delete this->svc_handler_;
00078
00079
00080 if (sh == 0)
00081 {
00082 ACE_NEW_RETURN (this->svc_handler_,
00083 SVC_HANDLER,
00084 -1);
00085 this->delete_svc_handler_ = true;
00086 }
00087 else
00088 {
00089 this->svc_handler_ = sh;
00090 this->delete_svc_handler_ = false;
00091 }
00092
00093 return 0;
00094 }
00095
00096 template <class SVC_HANDLER> int
00097 ACE_DLL_Strategy<SVC_HANDLER>::open (const ACE_TCHAR dll_name[],
00098 const ACE_TCHAR factory_function[],
00099 const ACE_TCHAR svc_name[],
00100 ACE_Service_Repository *svc_rep,
00101 ACE_Thread_Manager *thr_mgr)
00102 {
00103 ACE_TRACE ("ACE_DLL_Strategy<SVC_HANDLER>::open");
00104 this->inherited::open (thr_mgr);
00105 ACE_OS::strcpy (this->dll_name_, dll_name);
00106 ACE_OS::strcpy (this->factory_function_, factory_function);
00107 ACE_OS::strcpy (this->svc_name_, svc_name);
00108 this->svc_rep_ = svc_rep;
00109 return 0;
00110 }
00111
00112
00113
00114 template <class SVC_HANDLER> int
00115 ACE_DLL_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh)
00116 {
00117 ACE_TRACE ("ACE_DLL_Strategy<SVC_HANDLER>::make_svc_handler");
00118
00119
00120 ACE_SHLIB_HANDLE handle = ACE_OS::dlopen (this->dll_name_);
00121
00122
00123 #if defined (ACE_OPENVMS)
00124 SVC_HANDLER *(*factory)(void) =
00125 (SVC_HANDLER *(*)(void)) ACE::ldsymbol (handle,
00126 this->factory_function_);
00127 #else
00128 SVC_HANDLER *(*factory)(void) =
00129 (SVC_HANDLER *(*)(void)) ACE_OS::dlsym (handle,
00130 this->factory_function_);
00131 #endif
00132
00133
00134
00135 SVC_HANDLER *svc_handler = 0;
00136
00137 ACE_ALLOCATOR_RETURN (svc_handler, (*factory)(), -1);
00138
00139 if (svc_handler != 0)
00140 {
00141
00142
00143
00144 ACE_Service_Type_Impl *stp = 0;
00145 ACE_NEW_RETURN (stp,
00146 ACE_Service_Object_Type (svc_handler,
00147 this->svc_name_),
00148 -1);
00149
00150 ACE_Service_Type *srp = 0;
00151
00152 ACE_NEW_RETURN (srp,
00153 ACE_Service_Type (this->svc_name_,
00154 stp,
00155 handle,
00156 1),
00157 -1);
00158 if (srp == 0)
00159 {
00160 delete stp;
00161 errno = ENOMEM;
00162 return -1;
00163 }
00164
00165 if (this->svc_rep_->insert (srp) == -1)
00166 return -1;
00167
00168 }
00169
00170 sh = svc_handler;
00171 return 0;
00172 }
00173
00174
00175
00176
00177
00178 template <class SVC_HANDLER> int
00179 ACE_Concurrency_Strategy<SVC_HANDLER>::activate_svc_handler (SVC_HANDLER *svc_handler,
00180 void *arg)
00181 {
00182 ACE_TRACE ("ACE_Concurrency_Strategy<SVC_HANDLER>::activate_svc_handler");
00183
00184 int result = 0;
00185
00186
00187
00188 if (ACE_BIT_ENABLED (this->flags_, ACE_NONBLOCK) != 0)
00189 {
00190 if (svc_handler->peer ().enable (ACE_NONBLOCK) == -1)
00191 result = -1;
00192 }
00193
00194 else if (svc_handler->peer ().disable (ACE_NONBLOCK) == -1)
00195 result = -1;
00196
00197 if (result == 0 && svc_handler->open (arg) == -1)
00198 result = -1;
00199
00200 if (result == -1)
00201
00202
00203 svc_handler->close (NORMAL_CLOSE_OPERATION);
00204
00205 return result;
00206 }
00207
00208 template <class SVC_HANDLER> int
00209 ACE_Reactive_Strategy<SVC_HANDLER>::open (ACE_Reactor *reactor,
00210 ACE_Reactor_Mask mask,
00211 int flags)
00212 {
00213 ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::open");
00214 this->reactor_ = reactor;
00215 this->mask_ = mask;
00216 this->flags_ = flags;
00217
00218
00219 if (this->reactor_ == 0)
00220 return -1;
00221 else
00222 return 0;
00223 }
00224
00225 template <class SVC_HANDLER> int
00226 ACE_Reactive_Strategy<SVC_HANDLER>::activate_svc_handler (SVC_HANDLER *svc_handler,
00227 void *arg)
00228 {
00229 ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::activate_svc_handler");
00230
00231 int result = 0;
00232
00233 if (this->reactor_ == 0)
00234 result = -1;
00235
00236
00237 else if (this->reactor_->register_handler (svc_handler, this->mask_) == -1)
00238 result = -1;
00239
00240
00241 else if (this->reactor_->uses_event_associations ())
00242 {
00243
00244
00245
00246
00247
00248 if (svc_handler->open (arg) != -1)
00249 return 0;
00250 else
00251 result = -1;
00252 }
00253 else
00254
00255 return this->inherited::activate_svc_handler (svc_handler, arg);
00256
00257 if (result == -1)
00258
00259
00260 svc_handler->close (NORMAL_CLOSE_OPERATION);
00261
00262 return result;
00263 }
00264
00265 template <class SVC_HANDLER> int
00266 ACE_Thread_Strategy<SVC_HANDLER>::open (ACE_Thread_Manager *thr_mgr,
00267 long thr_flags,
00268 int n_threads,
00269 int flags)
00270 {
00271 ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::open");
00272 this->thr_mgr_ = thr_mgr;
00273 this->n_threads_ = n_threads;
00274 this->thr_flags_ = thr_flags;
00275 this->flags_ = flags;
00276
00277
00278 if (this->thr_mgr_ == 0)
00279 ACE_ERROR_RETURN ((LM_ERROR,
00280 ACE_TEXT ("error: must have a non-NULL thread manager\n")),
00281 -1);
00282 else
00283 return 0;
00284 }
00285
00286 template <class SVC_HANDLER> int
00287 ACE_Thread_Strategy<SVC_HANDLER>::activate_svc_handler (SVC_HANDLER *svc_handler,
00288 void *arg)
00289 {
00290 ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::activate_svc_handler");
00291
00292 if (this->inherited::activate_svc_handler (svc_handler,
00293 arg) == -1)
00294 return -1;
00295 else
00296
00297
00298 return svc_handler->activate (this->thr_flags_,
00299 this->n_threads_);
00300 }
00301
00302 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00303 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::open
00304 (const ACE_PEER_ACCEPTOR_ADDR &local_addr, bool reuse_addr)
00305 {
00306 this->reuse_addr_ = reuse_addr;
00307 this->peer_acceptor_addr_ = local_addr;
00308 if (this->peer_acceptor_.open (local_addr, reuse_addr) == -1)
00309 return -1;
00310
00311
00312
00313
00314
00315
00316
00317 this->peer_acceptor_.enable (ACE_NONBLOCK);
00318 return 0;
00319 }
00320
00321 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
00322 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy
00323 (const ACE_PEER_ACCEPTOR_ADDR &local_addr,
00324 bool reuse_addr,
00325 ACE_Reactor *reactor)
00326 : reactor_ (reactor)
00327 {
00328 ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy");
00329
00330 if (this->open (local_addr, reuse_addr) == -1)
00331 ACE_ERROR ((LM_ERROR,
00332 ACE_TEXT ("%p\n"),
00333 ACE_TEXT ("open")));
00334 }
00335
00336 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> int
00337 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler
00338 (SVC_HANDLER *svc_handler)
00339 {
00340 ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::accept_svc_handler");
00341
00342
00343
00344
00345
00346
00347 bool reset_new_handle = this->reactor_->uses_event_associations ();
00348
00349 if (this->peer_acceptor_.accept (svc_handler->peer (),
00350 0,
00351 0,
00352 1,
00353 reset_new_handle
00354 ) == -1)
00355 {
00356
00357
00358 ACE_Errno_Guard error(errno);
00359
00360
00361 svc_handler->close (CLOSE_DURING_NEW_CONNECTION);
00362
00363 return -1;
00364 }
00365 else
00366 return 0;
00367 }
00368
00369 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00370 ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
00371 (SVC_HANDLER *&sh,
00372 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00373 ACE_Time_Value *timeout,
00374 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00375 bool reuse_addr,
00376 int flags,
00377 int perms)
00378 {
00379 ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler");
00380
00381 return this->connector_.connect (sh->peer (),
00382 remote_addr,
00383 timeout,
00384 local_addr,
00385 reuse_addr,
00386 flags,
00387 perms);
00388 }
00389
00390 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> int
00391 ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler
00392 (SVC_HANDLER *&sh,
00393 SVC_HANDLER *&sh_copy,
00394 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00395 ACE_Time_Value *timeout,
00396 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00397 bool reuse_addr,
00398 int flags,
00399 int perms)
00400 {
00401 ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connect_svc_handler");
00402
00403 int const result =
00404 this->connector_.connect (sh->peer (),
00405 remote_addr,
00406 timeout,
00407 local_addr,
00408 reuse_addr,
00409 flags,
00410 perms);
00411 sh_copy = sh;
00412 return result;
00413 }
00414
00415 template <class SVC_HANDLER> int
00416 ACE_Process_Strategy<SVC_HANDLER>::open (size_t n_processes,
00417 ACE_Event_Handler *acceptor,
00418 ACE_Reactor *reactor,
00419 int avoid_zombies)
00420 {
00421 ACE_TRACE ("ACE_Process_Strategy<SVC_HANDLER>::open");
00422 this->n_processes_ = n_processes;
00423 this->acceptor_ = acceptor;
00424 this->reactor_ = reactor;
00425 this->flags_ = avoid_zombies;
00426
00427 return 0;
00428 }
00429
00430 template <class SVC_HANDLER> int
00431 ACE_Process_Strategy<SVC_HANDLER>::activate_svc_handler (SVC_HANDLER *svc_handler,
00432 void *arg)
00433 {
00434 ACE_TRACE ("ACE_Process_Strategy<SVC_HANDLER>::activate_svc_handler");
00435
00436
00437 switch (ACE::fork (ACE_TEXT ("child"), this->flags_))
00438 {
00439 case -1:
00440 {
00441 ACE_Errno_Guard error (errno);
00442 svc_handler->close ();
00443 }
00444 ACE_ERROR_RETURN ((LM_ERROR,
00445 ACE_TEXT ("%p\n"),
00446 ACE_TEXT ("fork")),
00447 -1);
00448
00449 case 0:
00450
00451
00452
00453 if (this->acceptor_ != 0)
00454
00455 (void) this->reactor_->remove_handler (this->acceptor_,
00456 ACE_Event_Handler::ACCEPT_MASK);
00457
00458
00459
00460 return this->inherited::activate_svc_handler (svc_handler, arg);
00461
00462 default:
00463
00464
00465 svc_handler->close ();
00466 return 0;
00467 }
00468 }
00469
00470 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX>
00471 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::ACE_Cached_Connect_Strategy
00472 (creation_strategy_type *cre_s,
00473 ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
00474 ACE_Recycling_Strategy<SVC_HANDLER> *rec_s,
00475 MUTEX *lock,
00476 bool delete_lock)
00477 : lock_ (lock),
00478 delete_lock_ (delete_lock),
00479 reverse_lock_ (0),
00480 creation_strategy_ (0),
00481 delete_creation_strategy_ (false),
00482 concurrency_strategy_ (0),
00483 delete_concurrency_strategy_ (false),
00484 recycling_strategy_ (0),
00485 delete_recycling_strategy_ (false)
00486 {
00487
00488 if (this->lock_ == 0)
00489 {
00490 ACE_NEW (this->lock_,
00491 MUTEX);
00492
00493 this->delete_lock_ = true;
00494 }
00495
00496 ACE_NEW (this->reverse_lock_,
00497 REVERSE_MUTEX (*this->lock_));
00498
00499 if (this->open (cre_s,
00500 con_s,
00501 rec_s) == -1)
00502 ACE_ERROR ((LM_ERROR,
00503 ACE_TEXT ("%p\n"),
00504 ACE_TEXT ("ACE_Cached_Connect_Strategy::ACE_Cached_Connect_Strategy")));
00505 }
00506
00507 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX>
00508 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::~ACE_Cached_Connect_Strategy (void)
00509 {
00510 if (this->delete_lock_)
00511 delete this->lock_;
00512
00513 delete this->reverse_lock_;
00514
00515 if (this->delete_creation_strategy_)
00516 delete this->creation_strategy_;
00517 this->delete_creation_strategy_ = false;
00518 this->creation_strategy_ = 0;
00519
00520 if (this->delete_concurrency_strategy_)
00521 delete this->concurrency_strategy_;
00522 this->delete_concurrency_strategy_ = false;
00523 this->concurrency_strategy_ = 0;
00524
00525 if (this->delete_recycling_strategy_)
00526 delete this->recycling_strategy_;
00527 this->delete_recycling_strategy_ = false;
00528 this->recycling_strategy_ = 0;
00529
00530
00531 CONNECTION_MAP_ENTRY *entry = 0;
00532 for (CONNECTION_MAP_ITERATOR iterator (connection_map_);
00533 iterator.next (entry);
00534 iterator.advance ())
00535 {
00536 entry->int_id_->recycler (0, 0);
00537 entry->int_id_->close ();
00538 }
00539 }
00540
00541 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00542 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::open
00543 (creation_strategy_type *cre_s,
00544 ACE_Concurrency_Strategy<SVC_HANDLER> *con_s,
00545 ACE_Recycling_Strategy<SVC_HANDLER> *rec_s)
00546 {
00547
00548
00549
00550 if (this->creation_strategy_ != 0 &&
00551 this->delete_creation_strategy_ &&
00552 cre_s != 0)
00553 {
00554 delete this->creation_strategy_;
00555 this->creation_strategy_ = 0;
00556 this->delete_creation_strategy_ = false;
00557 }
00558
00559 if (cre_s != 0)
00560 this->creation_strategy_ = cre_s;
00561 else if (this->creation_strategy_ == 0)
00562 {
00563 ACE_NEW_RETURN (this->creation_strategy_,
00564 CREATION_STRATEGY, -1);
00565 this->delete_creation_strategy_ = true;
00566 }
00567
00568
00569
00570 if (this->concurrency_strategy_ != 0 &&
00571 this->delete_concurrency_strategy_ &&
00572 con_s != 0)
00573 {
00574 delete this->concurrency_strategy_;
00575 this->concurrency_strategy_ = 0;
00576 this->delete_concurrency_strategy_ = false;
00577 }
00578
00579 if (con_s != 0)
00580 this->concurrency_strategy_ = con_s;
00581 else if (this->concurrency_strategy_ == 0)
00582 {
00583 ACE_NEW_RETURN (this->concurrency_strategy_,
00584 CONCURRENCY_STRATEGY, -1);
00585 this->delete_concurrency_strategy_ = true;
00586 }
00587
00588
00589
00590 if (this->recycling_strategy_ != 0 &&
00591 this->delete_recycling_strategy_ &&
00592 rec_s != 0)
00593 {
00594 delete this->recycling_strategy_;
00595 this->recycling_strategy_ = 0;
00596 this->delete_recycling_strategy_ = false;
00597 }
00598
00599 if (rec_s != 0)
00600 this->recycling_strategy_ = rec_s;
00601 else if (this->recycling_strategy_ == 0)
00602 {
00603 ACE_NEW_RETURN (this->recycling_strategy_,
00604 RECYCLING_STRATEGY, -1);
00605 this->delete_recycling_strategy_ = true;
00606 }
00607
00608 return 0;
00609 }
00610
00611 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00612 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::make_svc_handler
00613 (SVC_HANDLER *&sh)
00614 {
00615 return this->creation_strategy_->make_svc_handler (sh);
00616 }
00617
00618 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00619 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::activate_svc_handler
00620 (SVC_HANDLER *svc_handler)
00621 {
00622 return this->concurrency_strategy_->activate_svc_handler (svc_handler);
00623 }
00624
00625 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00626 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::assign_recycler
00627 (SVC_HANDLER *svc_handler,
00628 ACE_Connection_Recycling_Strategy *recycler,
00629 const void *recycling_act)
00630 {
00631 return this->recycling_strategy_->assign_recycler (svc_handler,
00632 recycler,
00633 recycling_act);
00634 }
00635
00636 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00637 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::prepare_for_recycling
00638 (SVC_HANDLER *svc_handler)
00639 {
00640 return this->recycling_strategy_->prepare_for_recycling (svc_handler);
00641 }
00642
00643 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00644 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::check_hint_i
00645 (SVC_HANDLER *&sh,
00646 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00647 ACE_Time_Value *timeout,
00648 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00649 bool reuse_addr,
00650 int flags,
00651 int perms,
00652 CONNECTION_MAP_ENTRY *&entry,
00653 int &found)
00654 {
00655 ACE_UNUSED_ARG (remote_addr);
00656 ACE_UNUSED_ARG (timeout);
00657 ACE_UNUSED_ARG (local_addr);
00658 ACE_UNUSED_ARG (reuse_addr);
00659 ACE_UNUSED_ARG (flags);
00660 ACE_UNUSED_ARG (perms);
00661
00662 found = 0;
00663
00664
00665 CONNECTION_MAP_ENTRY *possible_entry = (CONNECTION_MAP_ENTRY *) sh->recycling_act ();
00666
00667
00668 if (possible_entry->ext_id_.recycle_state () == ACE_RECYCLABLE_CLOSED)
00669 {
00670
00671 if (possible_entry->ext_id_.decrement () == 0)
00672 {
00673
00674 possible_entry->int_id_->recycler (0, 0);
00675 possible_entry->int_id_->close ();
00676 this->purge_i (possible_entry);
00677 }
00678
00679
00680 found = 0;
00681
00682
00683 sh = 0;
00684 }
00685
00686
00687
00688 else if ((possible_entry->ext_id_.recycle_state () == ACE_RECYCLABLE_IDLE_AND_PURGABLE ||
00689 possible_entry->ext_id_.recycle_state () == ACE_RECYCLABLE_IDLE_BUT_NOT_PURGABLE) &&
00690 possible_entry->ext_id_.subject () == remote_addr)
00691 {
00692
00693 found = 1;
00694
00695
00696
00697 this->prepare_for_recycling (sh);
00698 }
00699 else
00700 {
00701
00702 possible_entry->ext_id_.decrement ();
00703
00704
00705 found = 0;
00706
00707
00708
00709 sh = 0;
00710 }
00711
00712 if (found)
00713 entry = possible_entry;
00714
00715 return 0;
00716 }
00717
00718 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00719 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::find_or_create_svc_handler_i
00720 (SVC_HANDLER *&sh,
00721 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00722 ACE_Time_Value *timeout,
00723 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00724 bool reuse_addr,
00725 int flags,
00726 int perms,
00727 CONNECTION_MAP_ENTRY *&entry,
00728 int &found)
00729 {
00730
00731 REFCOUNTED_HASH_RECYCLABLE_ADDRESS search_addr (remote_addr);
00732
00733
00734
00735 if (this->find (search_addr, entry) == -1)
00736 {
00737
00738 found = 0;
00739
00740
00741
00742
00743
00744
00745
00746
00747 SVC_HANDLER *potential_handler = 0;
00748
00749
00750 if (this->make_svc_handler (potential_handler) == -1)
00751 return -1;
00752
00753
00754
00755 if (this->new_connection (potential_handler,
00756 remote_addr,
00757 timeout,
00758 local_addr,
00759 reuse_addr,
00760 flags,
00761 perms) == -1)
00762 {
00763
00764
00765
00766
00767
00768 if (errno == EWOULDBLOCK)
00769 errno = ENOTSUP;
00770
00771
00772 potential_handler->close (0);
00773
00774 return -1;
00775 }
00776 else
00777 {
00778
00779 if (this->connection_map_.bind (search_addr,
00780 potential_handler,
00781 entry) == -1)
00782 {
00783
00784 potential_handler->close (CLOSE_DURING_NEW_CONNECTION);
00785
00786 return -1;
00787 }
00788
00789
00790 sh = potential_handler;
00791
00792
00793 this->assign_recycler (sh, this, entry);
00794 }
00795 }
00796 else
00797
00798 {
00799
00800 found = 1;
00801
00802
00803 sh = entry->int_id_;
00804
00805
00806
00807 this->prepare_for_recycling (sh);
00808 }
00809
00810 return 0;
00811 }
00812
00813 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00814 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::new_connection
00815 (SVC_HANDLER *&sh,
00816 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00817 ACE_Time_Value *timeout,
00818 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00819 bool reuse_addr,
00820 int flags,
00821 int perms)
00822 {
00823
00824
00825
00826 ACE_GUARD_RETURN (REVERSE_MUTEX, ace_mon, *this->reverse_lock_, -1);
00827
00828 return this->CONNECT_STRATEGY::connect_svc_handler (sh,
00829 remote_addr,
00830 timeout,
00831 local_addr,
00832 reuse_addr,
00833 flags,
00834 perms);
00835 }
00836
00837 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00838 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::connect_svc_handler
00839 (SVC_HANDLER *&sh,
00840 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00841 ACE_Time_Value *timeout,
00842 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00843 bool reuse_addr,
00844 int flags,
00845 int perms)
00846 {
00847 int found = 0;
00848
00849
00850
00851
00852 {
00853
00854
00855
00856 ACE_GUARD_RETURN (MUTEX, ace_mon, *this->lock_, -1);
00857
00858 int result = this->connect_svc_handler_i (sh,
00859 remote_addr,
00860 timeout,
00861 local_addr,
00862 reuse_addr,
00863 flags,
00864 perms,
00865 found);
00866 if (result != 0)
00867 return result;
00868
00869 }
00870
00871
00872
00873
00874
00875
00876
00877 if (!found)
00878 {
00879 if (this->activate_svc_handler (sh) == -1)
00880 {
00881
00882
00883
00884
00885
00886
00887
00888
00889 ACE_GUARD_RETURN (MUTEX, ace_mon, *this->lock_, -1);
00890
00891
00892 sh = 0;
00893
00894 return -1;
00895 }
00896 }
00897
00898 return 0;
00899 }
00900
00901 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00902 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::connect_svc_handler
00903 (SVC_HANDLER *&sh,
00904 SVC_HANDLER *&sh_copy,
00905 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00906 ACE_Time_Value *timeout,
00907 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00908 bool reuse_addr,
00909 int flags,
00910 int perms)
00911 {
00912 int found = 0;
00913
00914
00915
00916
00917 {
00918
00919
00920
00921 ACE_GUARD_RETURN (MUTEX, ace_mon, *this->lock_, -1);
00922
00923 int result = this->connect_svc_handler_i (sh,
00924 remote_addr,
00925 timeout,
00926 local_addr,
00927 reuse_addr,
00928 flags,
00929 perms,
00930 found);
00931 sh_copy = sh;
00932
00933 if (result != 0)
00934 return result;
00935
00936 }
00937
00938
00939
00940
00941
00942
00943
00944 if (!found)
00945 {
00946 if (this->activate_svc_handler (sh_copy) == -1)
00947 {
00948
00949
00950
00951
00952
00953
00954
00955
00956 ACE_GUARD_RETURN (MUTEX, ace_mon, *this->lock_, -1);
00957
00958
00959 sh = 0;
00960 sh_copy = 0;
00961
00962 return -1;
00963 }
00964 }
00965
00966 return 0;
00967 }
00968
00969 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
00970 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::connect_svc_handler_i
00971 (SVC_HANDLER *&sh,
00972 const ACE_PEER_CONNECTOR_ADDR &remote_addr,
00973 ACE_Time_Value *timeout,
00974 const ACE_PEER_CONNECTOR_ADDR &local_addr,
00975 bool reuse_addr,
00976 int flags,
00977 int perms,
00978 int& found)
00979 {
00980 CONNECTION_MAP_ENTRY *entry = 0;
00981
00982
00983 if (sh != 0)
00984 {
00985 int result = this->check_hint_i (sh,
00986 remote_addr,
00987 timeout,
00988 local_addr,
00989 reuse_addr,
00990 flags,
00991 perms,
00992 entry,
00993 found);
00994 if (result != 0)
00995 return result;
00996 }
00997
00998
00999 if (!found)
01000 {
01001 int result = this->find_or_create_svc_handler_i (sh,
01002 remote_addr,
01003 timeout,
01004 local_addr,
01005 reuse_addr,
01006 flags,
01007 perms,
01008 entry,
01009 found);
01010 if (result != 0)
01011 return result;
01012 }
01013
01014
01015
01016 entry->ext_id_.recycle_state (ACE_RECYCLABLE_BUSY);
01017
01018
01019 entry->ext_id_.increment ();
01020
01021 return 0;
01022 }
01023
01024 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01025 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::cache (const void *recycling_act)
01026 {
01027
01028
01029
01030 ACE_GUARD_RETURN (MUTEX, ace_mon, *this->lock_, -1);
01031
01032 return this->cache_i (recycling_act);
01033 }
01034
01035 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01036 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::cache_i (const void *recycling_act)
01037 {
01038
01039 CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
01040
01041
01042
01043 entry->ext_id_.recycle_state (ACE_RECYCLABLE_IDLE_AND_PURGABLE);
01044
01045 return 0;
01046 }
01047
01048 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01049 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::recycle_state (const void *recycling_act,
01050 ACE_Recyclable_State new_state)
01051 {
01052
01053
01054
01055 ACE_GUARD_RETURN (MUTEX, ace_mon, *this->lock_, -1);
01056
01057 return this->recycle_state_i (recycling_act,
01058 new_state);
01059 }
01060
01061 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01062 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::recycle_state_i (const void *recycling_act,
01063 ACE_Recyclable_State new_state)
01064 {
01065
01066 CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
01067
01068
01069
01070 entry->ext_id_.recycle_state (new_state);
01071
01072 return 0;
01073 }
01074
01075 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_Recyclable_State
01076 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::recycle_state (const void *recycling_act) const
01077 {
01078
01079 SELF *fake_this = const_cast<SELF *> (this);
01080
01081
01082 ACE_GUARD_RETURN (MUTEX, ace_mon, *fake_this->lock_, ACE_RECYCLABLE_UNKNOWN);
01083
01084 return this->recycle_state_i (recycling_act);
01085 }
01086
01087 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_Recyclable_State
01088 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::recycle_state_i (const void *recycling_act) const
01089 {
01090
01091 CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
01092
01093
01094
01095 return entry->ext_id_.recycle_state ();
01096 }
01097
01098 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01099 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::purge (const void *recycling_act)
01100 {
01101
01102
01103 ACE_GUARD_RETURN (MUTEX, ace_mon, *this->lock_, -1);
01104
01105 return this->purge_i (recycling_act);
01106 }
01107
01108 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01109 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::purge_i (const void *recycling_act)
01110 {
01111
01112 CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
01113
01114 return this->connection_map_.unbind (entry);
01115 }
01116
01117 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01118 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::mark_as_closed (const void *recycling_act)
01119 {
01120
01121
01122 ACE_GUARD_RETURN (MUTEX, ace_mon, *this->lock_, -1);
01123
01124 return this->mark_as_closed_i (recycling_act);
01125 }
01126
01127 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01128 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::mark_as_closed_i (const void *recycling_act)
01129 {
01130
01131 CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
01132
01133
01134 entry->ext_id_.recycle_state (ACE_RECYCLABLE_CLOSED);
01135
01136 return 0;
01137 }
01138
01139 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01140 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::cleanup_hint (const void *recycling_act,
01141 void **act_holder)
01142 {
01143
01144
01145 ACE_GUARD_RETURN (MUTEX, ace_mon, *this->lock_, -1);
01146
01147 return this->cleanup_hint_i (recycling_act,
01148 act_holder);
01149 }
01150
01151 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01152 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::cleanup_hint_i (const void *recycling_act,
01153 void **act_holder)
01154 {
01155
01156
01157 if (act_holder)
01158 *act_holder = 0;
01159
01160
01161 CONNECTION_MAP_ENTRY *entry = (CONNECTION_MAP_ENTRY *) recycling_act;
01162
01163
01164 int refcount = entry->ext_id_.decrement ();
01165
01166
01167
01168 if (entry->ext_id_.recycle_state () == ACE_RECYCLABLE_CLOSED &&
01169 refcount == 0)
01170 {
01171 entry->int_id_->recycler (0, 0);
01172 entry->int_id_->close ();
01173 this->purge_i (entry);
01174 }
01175
01176 return 0;
01177 }
01178
01179 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_Creation_Strategy<SVC_HANDLER> *
01180 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::creation_strategy (void) const
01181 {
01182 return this->creation_strategy_;
01183 }
01184
01185 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_Recycling_Strategy<SVC_HANDLER> *
01186 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::recycling_strategy (void) const
01187 {
01188 return this->recycling_strategy_;
01189 }
01190
01191 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_Concurrency_Strategy<SVC_HANDLER> *
01192 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::concurrency_strategy (void) const
01193 {
01194 return this->concurrency_strategy_;
01195 }
01196
01197 template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int
01198 ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::find (
01199 REFCOUNTED_HASH_RECYCLABLE_ADDRESS &search_addr,
01200 CONNECTION_MAP_ENTRY *&entry)
01201 {
01202 typedef ACE_Hash_Map_Bucket_Iterator<REFCOUNTED_HASH_RECYCLABLE_ADDRESS,
01203 SVC_HANDLER *,
01204 ACE_Hash<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>,
01205 ACE_Equal_To<REFCOUNTED_HASH_RECYCLABLE_ADDRESS>,
01206 ACE_Null_Mutex>
01207 CONNECTION_MAP_BUCKET_ITERATOR;
01208
01209 CONNECTION_MAP_BUCKET_ITERATOR iterator (this->connection_map_,
01210 search_addr);
01211
01212 CONNECTION_MAP_BUCKET_ITERATOR end (this->connection_map_,
01213 search_addr,
01214 1);
01215
01216 for (;
01217 iterator != end;
01218 ++iterator)
01219 {
01220 REFCOUNTED_HASH_RECYCLABLE_ADDRESS &addr = (*iterator).ext_id_;
01221
01222 if (addr.recycle_state () != ACE_RECYCLABLE_IDLE_AND_PURGABLE &&
01223 addr.recycle_state () != ACE_RECYCLABLE_IDLE_BUT_NOT_PURGABLE)
01224 continue;
01225
01226 if (addr.subject () != search_addr.subject ())
01227 continue;
01228
01229 entry = &(*iterator);
01230 return 0;
01231 }
01232
01233 return -1;
01234 }
01235
01236 template <class SVC_HANDLER> void
01237 ACE_DLL_Strategy<SVC_HANDLER>::dump (void) const
01238 {
01239 #if defined (ACE_HAS_DUMP)
01240 ACE_TRACE ("ACE_DLL_Strategy<SVC_HANDLER>::dump");
01241 #endif
01242 }
01243
01244 template <class SVC_HANDLER>
01245 ACE_Concurrency_Strategy<SVC_HANDLER>::~ACE_Concurrency_Strategy (void)
01246 {
01247 ACE_TRACE ("ACE_Concurrency_Strategy<SVC_HANDLER>::~ACE_Concurrency_Strategy");
01248 }
01249
01250
01251 template <class SVC_HANDLER> void
01252 ACE_Concurrency_Strategy<SVC_HANDLER>::dump (void) const
01253 {
01254 #if defined (ACE_HAS_DUMP)
01255 ACE_TRACE ("ACE_Concurrency_Strategy<SVC_HANDLER>::dump");
01256 #endif
01257 }
01258
01259 template <class SVC_HANDLER>
01260 ACE_Reactive_Strategy<SVC_HANDLER>::~ACE_Reactive_Strategy (void)
01261 {
01262 ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::~ACE_Reactive_Strategy");
01263 }
01264
01265
01266 template <class SVC_HANDLER> void
01267 ACE_Reactive_Strategy<SVC_HANDLER>::dump (void) const
01268 {
01269 #if defined (ACE_HAS_DUMP)
01270 ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::dump");
01271 #endif
01272 }
01273
01274 template <class SVC_HANDLER>
01275 ACE_Thread_Strategy<SVC_HANDLER>::~ACE_Thread_Strategy (void)
01276 {
01277 ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::~ACE_Thread_Strategy");
01278 }
01279
01280 template <class SVC_HANDLER> void
01281 ACE_Thread_Strategy<SVC_HANDLER>::dump (void) const
01282 {
01283 #if defined (ACE_HAS_DUMP)
01284 ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::dump");
01285 #endif
01286 }
01287
01288 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1>
01289 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Accept_Strategy (void)
01290 {
01291 ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Accept_Strategy");
01292
01293
01294 this->peer_acceptor_.close ();
01295 }
01296
01297 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_HANDLE
01298 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const
01299 {
01300 ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle");
01301 return this->peer_acceptor_.get_handle ();
01302 }
01303
01304 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_PEER_ACCEPTOR &
01305 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor (void) const
01306 {
01307 ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor");
01308 return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_;
01309 }
01310
01311 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> void
01312 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const
01313 {
01314 #if defined (ACE_HAS_DUMP)
01315 ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump");
01316 #endif
01317 }
01318
01319 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1>
01320 ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connect_Strategy (void)
01321 {
01322 ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connect_Strategy");
01323 }
01324
01325 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_PEER_CONNECTOR &
01326 ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connector (void) const
01327 {
01328 ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connector");
01329 return (ACE_PEER_CONNECTOR &) this->connector_;
01330 }
01331
01332 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> void
01333 ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::dump (void) const
01334 {
01335 #if defined (ACE_HAS_DUMP)
01336 ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::dump");
01337 #endif
01338 }
01339
01340 template <class SVC_HANDLER>
01341 ACE_Process_Strategy<SVC_HANDLER>::~ACE_Process_Strategy (void)
01342 {
01343 ACE_TRACE ("ACE_Process_Strategy<SVC_HANDLER>::~ACE_Process_Strategy");
01344 }
01345
01346 template <class SVC_HANDLER> void
01347 ACE_Process_Strategy<SVC_HANDLER>::dump (void) const
01348 {
01349 #if defined (ACE_HAS_DUMP)
01350 ACE_TRACE ("ACE_Process_Strategy<SVC_HANDLER>::dump");
01351 #endif
01352 }
01353
01354 template <class SVC_HANDLER>
01355 ACE_Scheduling_Strategy<SVC_HANDLER>::~ACE_Scheduling_Strategy (void)
01356 {
01357 ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::~ACE_Scheduling_Strategy");
01358 }
01359
01360 template <class SVC_HANDLER> int
01361 ACE_Scheduling_Strategy<SVC_HANDLER>::suspend (void)
01362 {
01363 ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::suspend");
01364 return -1;
01365 }
01366
01367 template <class SVC_HANDLER> int
01368 ACE_Scheduling_Strategy<SVC_HANDLER>::resume (void)
01369 {
01370 ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::resume");
01371 return -1;
01372 }
01373
01374 template <class SVC_HANDLER> void
01375 ACE_Scheduling_Strategy<SVC_HANDLER>::dump (void) const
01376 {
01377 #if defined (ACE_HAS_DUMP)
01378 ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::dump");
01379
01380 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
01381 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
01382 #endif
01383 }
01384
01385 template <class SVC_HANDLER> int
01386 ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::suspend (void)
01387 {
01388 ACE_TRACE ("ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::suspend");
01389 return this->reactor_->suspend_handlers ();
01390 }
01391
01392 template <class SVC_HANDLER> int
01393 ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::resume (void)
01394 {
01395 ACE_TRACE ("ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::resume");
01396 return this->reactor_->resume_handlers ();
01397 }
01398
01399 template <class SVC_HANDLER> void
01400 ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::dump (void) const
01401 {
01402 #if defined (ACE_HAS_DUMP)
01403 ACE_TRACE ("ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::dump");
01404
01405 ACE_Scheduling_Strategy<SVC_HANDLER>::dump ();
01406 #endif
01407 }
01408
01409 template <class SVC_HANDLER> int
01410 ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::suspend (void)
01411 {
01412 ACE_TRACE ("ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::suspend");
01413 return this->thr_mgr_->suspend_all ();
01414 }
01415
01416 template <class SVC_HANDLER> int
01417 ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::resume (void)
01418 {
01419 ACE_TRACE ("ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::resume");
01420 return this->thr_mgr_->resume_all ();
01421 }
01422
01423 template <class SVC_HANDLER> void
01424 ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::dump (void) const
01425 {
01426 #if defined (ACE_HAS_DUMP)
01427 ACE_TRACE ("ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::dump");
01428
01429 ACE_Scheduling_Strategy<SVC_HANDLER>::dump ();
01430 #endif
01431 }
01432
01433 template <class T>
01434 ACE_Refcounted_Hash_Recyclable<T>::~ACE_Refcounted_Hash_Recyclable (void)
01435 {
01436 }
01437
01438 template <class SVC_HANDLER> void
01439 ACE_Singleton_Strategy<SVC_HANDLER>::dump (void) const
01440 {
01441 #if defined (ACE_HAS_DUMP)
01442 ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::dump");
01443 #endif
01444 }
01445
01446 template <class SVC_HANDLER>
01447 ACE_Creation_Strategy<SVC_HANDLER>::~ACE_Creation_Strategy (void)
01448 {
01449 ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::~ACE_Creation_Strategy");
01450 }
01451
01452
01453
01454
01455 template <class SVC_HANDLER> int
01456 ACE_Creation_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh)
01457 {
01458 ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::make_svc_handler");
01459
01460 if (sh == 0)
01461 ACE_NEW_RETURN (sh, SVC_HANDLER (this->thr_mgr_), -1);
01462 sh->reactor (this->reactor_);
01463 return 0;
01464 }
01465
01466 template <class SVC_HANDLER> void
01467 ACE_Creation_Strategy<SVC_HANDLER>::dump (void) const
01468 {
01469 #if defined (ACE_HAS_DUMP)
01470 ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::dump");
01471 #endif
01472 }
01473
01474 template <class SVC_HANDLER> int
01475 ACE_NOOP_Creation_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&)
01476 {
01477 ACE_TRACE ("ACE_NOOP_Creation_Strategy<SVC_HANDLER>::make_svc_handler");
01478 return 0;
01479 }
01480
01481 template <class SVC_HANDLER> int
01482 ACE_NOOP_Concurrency_Strategy<SVC_HANDLER>::activate_svc_handler (SVC_HANDLER *,
01483 void *)
01484 {
01485 ACE_TRACE ("ACE_NOOP_Concurrency_Strategy<SVC_HANDLER>::activate_svc_handler");
01486 return 0;
01487 }
01488
01489
01490 ACE_ALLOC_HOOK_DEFINE(ACE_Creation_Strategy)
01491 ACE_ALLOC_HOOK_DEFINE(ACE_Singleton_Strategy)
01492 ACE_ALLOC_HOOK_DEFINE(ACE_DLL_Strategy)
01493 ACE_ALLOC_HOOK_DEFINE(ACE_Concurrency_Strategy)
01494 ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Strategy)
01495 ACE_ALLOC_HOOK_DEFINE(ACE_Connect_Strategy)
01496 ACE_ALLOC_HOOK_DEFINE(ACE_Process_Strategy)
01497 ACE_ALLOC_HOOK_DEFINE(ACE_Accept_Strategy)
01498 ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Strategy)
01499
01500 ACE_END_VERSIONED_NAMESPACE_DECL
01501
01502 #endif