diff options
Diffstat (limited to 'ACE/ace/Strategies_T.inl')
| -rw-r--r-- | ACE/ace/Strategies_T.inl | 230 |
1 files changed, 230 insertions, 0 deletions
diff --git a/ACE/ace/Strategies_T.inl b/ACE/ace/Strategies_T.inl new file mode 100644 index 00000000000..a6a6d1dfd1a --- /dev/null +++ b/ACE/ace/Strategies_T.inl @@ -0,0 +1,230 @@ +// -*- C++ -*- +// +// $Id$ + +ACE_BEGIN_VERSIONED_NAMESPACE_DECL + +template <class SVC_HANDLER> ACE_INLINE +ACE_Singleton_Strategy<SVC_HANDLER>::ACE_Singleton_Strategy (SVC_HANDLER *sh, + ACE_Thread_Manager *tm) + : svc_handler_ (0), + delete_svc_handler_ (1) +{ + ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::ACE_Singleton_Strategy"); + if (this->open (sh, tm) == -1) + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("%p\n"), + ACE_LIB_TEXT ("ACE_Singleton_Strategy"))); +} + +template <class SVC_HANDLER> ACE_INLINE int +ACE_Creation_Strategy<SVC_HANDLER>::open (ACE_Thread_Manager *thr_mgr, + ACE_Reactor *reactor) +{ + ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::open"); + this->thr_mgr_ = thr_mgr; + this->reactor_ = reactor; + return 0; +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Creation_Strategy<SVC_HANDLER>::ACE_Creation_Strategy (ACE_Thread_Manager *thr_mgr, + ACE_Reactor *reactor) +{ + ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::ACE_Creation_Strategy"); + if (this->open (thr_mgr, reactor) == -1) + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("%p\n"), + ACE_LIB_TEXT ("ACE_Creation_Strategy"))); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_DLL_Strategy<SVC_HANDLER>::ACE_DLL_Strategy (const ACE_TCHAR dll_name[], + const ACE_TCHAR factory_function[], + const ACE_TCHAR svc_name[], + ACE_Service_Repository *svc_rep, + ACE_Thread_Manager *thr_mgr) +{ + ACE_TRACE ("ACE_DLL_Strategy<SVC_HANDLER>::ACE_DLL_Strategy"); + if (this->open (dll_name, + factory_function, + svc_name, + svc_rep, + thr_mgr) == -1) + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("%p\n"), + ACE_LIB_TEXT ("open"))); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_DLL_Strategy<SVC_HANDLER>::ACE_DLL_Strategy (void) +{ + ACE_TRACE ("ACE_DLL_Strategy<SVC_HANDLER>::ACE_DLL_Strategy"); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Concurrency_Strategy<SVC_HANDLER>::ACE_Concurrency_Strategy (int flags) + : flags_ (flags) +{ + ACE_TRACE ("ACE_Concurrency_Strategy<SVC_HANDLER>::ACE_Concurrency_Strategy"); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy (ACE_Reactor *reactor, + ACE_Reactor_Mask mask, + int flags) +{ + ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy"); + + if (this->open (reactor, + mask, + flags) == -1) + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("%p\n"), + ACE_LIB_TEXT ("ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy"))); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy (int flags) + : ACE_Concurrency_Strategy<SVC_HANDLER> (flags), + reactor_ (0), + mask_ (ACE_Event_Handler::NULL_MASK) +{ + ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy"); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy (ACE_Thread_Manager *thr_mgr, + long thr_flags, + int n_threads, + int flags) +{ + ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy"); + + if (this->open (thr_mgr, + thr_flags, + n_threads, + flags) == -1) + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("%p\n"), + ACE_LIB_TEXT ("ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy"))); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy (int flags) + : ACE_Concurrency_Strategy<SVC_HANDLER> (flags), + thr_mgr_ (0), + thr_flags_ (0), + n_threads_ (1) +{ + ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy"); +} + +template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_INLINE +ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy (ACE_Reactor *reactor) + : reactor_ (reactor) +{ + ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy"); +} + +template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_INLINE +ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connect_Strategy (void) +{ + ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connect_Strategy"); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Process_Strategy<SVC_HANDLER>::ACE_Process_Strategy (size_t n_processes, + ACE_Event_Handler *acceptor, + ACE_Reactor *reactor, + int avoid_zombies) +{ + ACE_TRACE ("ACE_Process_Strategy<SVC_HANDLER>::ACE_Process_Strategy"); + if (this->open (n_processes, + acceptor, + reactor, + avoid_zombies) == -1) + ACE_ERROR ((LM_ERROR, + ACE_LIB_TEXT ("%p\n"), + ACE_LIB_TEXT ("ACE_Process_Strategy"))); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Scheduling_Strategy<SVC_HANDLER>::ACE_Scheduling_Strategy (SVC_HANDLER *) +{ + ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::ACE_Scheduling_Strategy"); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::ACE_Schedule_All_Reactive_Strategy + (SVC_HANDLER *scheduler) + : ACE_Scheduling_Strategy<SVC_HANDLER> (scheduler) +{ + ACE_TRACE ("ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::ACE_Schedule_All_Reactive_Strategy"); + + if (scheduler == 0 || scheduler->reactor () == 0) + this->reactor_ = ACE_Reactor::instance (); + else + this->reactor_ = scheduler->reactor (); +} + +template <class SVC_HANDLER> ACE_INLINE +ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::ACE_Schedule_All_Threaded_Strategy + (SVC_HANDLER *scheduler) + : ACE_Scheduling_Strategy<SVC_HANDLER> (scheduler) +{ + ACE_TRACE ("ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::ACE_Schedule_All_Threaded_Strategy"); + + if (scheduler == 0 || scheduler->thr_mgr () == 0) + this->thr_mgr_ = ACE_Thread_Manager::instance (); + else + this->thr_mgr_ = scheduler->thr_mgr (); +} + +template <class T> ACE_INLINE +ACE_Refcounted_Hash_Recyclable<T>::ACE_Refcounted_Hash_Recyclable (void) + : ACE_Refcountable (0), + ACE_Hashable (), + ACE_Recyclable (ACE_RECYCLABLE_UNKNOWN), + t_ () +{ +} + +template <class T> ACE_INLINE +ACE_Refcounted_Hash_Recyclable<T>::ACE_Refcounted_Hash_Recyclable (const T &t, + int refcount, + ACE_Recyclable_State state) + : ACE_Refcountable (refcount), + ACE_Hashable (), + ACE_Recyclable (state), + t_ (t) +{ +} + +template <class T> ACE_INLINE u_long +ACE_Refcounted_Hash_Recyclable<T>::hash_i (void) const +{ + return this->t_.hash (); +} + +template <class T> ACE_INLINE T & +ACE_Refcounted_Hash_Recyclable<T>::subject (void) +{ + return this->t_; +} + +template <class T> ACE_INLINE bool +ACE_Refcounted_Hash_Recyclable<T>::operator== (const ACE_Refcounted_Hash_Recyclable<T> &rhs) const +{ + return + this->recycle_state () == rhs.recycle_state () + && this->t_ == rhs.t_; +} + +template <class T> ACE_INLINE bool +ACE_Refcounted_Hash_Recyclable<T>::operator!= (const ACE_Refcounted_Hash_Recyclable<T> &rhs) const +{ + return !this->operator== (rhs); +} + +ACE_END_VERSIONED_NAMESPACE_DECL |