dep/ACE_wrappers/ace/Strategies_T.inl

   1 // -*- C++ -*-
   2 //
   3 // $Id: Strategies_T.inl 81503 2008-04-28 18:28:15Z johnnyw $
   4
   5 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   6
   7 template <class SVC_HANDLER> ACE_INLINE
   8 ACE_Singleton_Strategy<SVC_HANDLER>::ACE_Singleton_Strategy (SVC_HANDLER *sh,
   9                                                              ACE_Thread_Manager *tm)
  10   : svc_handler_ (0),
  11     delete_svc_handler_ (1)
  12 {
  13   ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::ACE_Singleton_Strategy");
  14   if (this->open (sh, tm) == -1)
  15     ACE_ERROR ((LM_ERROR,
  16                 ACE_TEXT ("%p\n"),
  17                 ACE_TEXT ("ACE_Singleton_Strategy")));
  18 }
  19
  20 template <class SVC_HANDLER> ACE_INLINE int
  21 ACE_Creation_Strategy<SVC_HANDLER>::open (ACE_Thread_Manager *thr_mgr,
  22                                           ACE_Reactor *reactor)
  23 {
  24   ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::open");
  25   this->thr_mgr_ = thr_mgr;
  26   this->reactor_ = reactor;
  27   return 0;
  28 }
  29
  30 template <class SVC_HANDLER> ACE_INLINE
  31 ACE_Creation_Strategy<SVC_HANDLER>::ACE_Creation_Strategy (ACE_Thread_Manager *thr_mgr,
  32                                                            ACE_Reactor *reactor)
  33 {
  34   ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::ACE_Creation_Strategy");
  35   if (this->open (thr_mgr, reactor) == -1)
  36     ACE_ERROR ((LM_ERROR,
  37                 ACE_TEXT ("%p\n"),
  38                 ACE_TEXT ("ACE_Creation_Strategy")));
  39 }
  40
  41 template <class SVC_HANDLER> ACE_INLINE
  42 ACE_DLL_Strategy<SVC_HANDLER>::ACE_DLL_Strategy (const ACE_TCHAR dll_name[],
  43                                                  const ACE_TCHAR factory_function[],
  44                                                  const ACE_TCHAR svc_name[],
  45                                                  ACE_Service_Repository *svc_rep,
  46                                                  ACE_Thread_Manager *thr_mgr)
  47 {
  48   ACE_TRACE ("ACE_DLL_Strategy<SVC_HANDLER>::ACE_DLL_Strategy");
  49   if (this->open (dll_name,
  50                   factory_function,
  51                   svc_name,
  52                   svc_rep,
  53                   thr_mgr) == -1)
  54     ACE_ERROR ((LM_ERROR,
  55                 ACE_TEXT ("%p\n"),
  56                 ACE_TEXT ("open")));
  57 }
  58
  59 template <class SVC_HANDLER> ACE_INLINE
  60 ACE_DLL_Strategy<SVC_HANDLER>::ACE_DLL_Strategy (void)
  61 {
  62   ACE_TRACE ("ACE_DLL_Strategy<SVC_HANDLER>::ACE_DLL_Strategy");
  63 }
  64
  65 template <class SVC_HANDLER> ACE_INLINE
  66 ACE_Concurrency_Strategy<SVC_HANDLER>::ACE_Concurrency_Strategy (int flags)
  67   : flags_ (flags)
  68 {
  69   ACE_TRACE ("ACE_Concurrency_Strategy<SVC_HANDLER>::ACE_Concurrency_Strategy");
  70 }
  71
  72 template <class SVC_HANDLER> ACE_INLINE
  73 ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy (ACE_Reactor *reactor,
  74                                                            ACE_Reactor_Mask mask,
  75                                                            int flags)
  76 {
  77   ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy");
  78
  79   if (this->open (reactor,
  80                   mask,
  81                   flags) == -1)
  82     ACE_ERROR ((LM_ERROR,
  83                 ACE_TEXT ("%p\n"),
  84                 ACE_TEXT ("ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy")));
  85 }
  86
  87 template <class SVC_HANDLER> ACE_INLINE
  88 ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy (int flags)
  89   : ACE_Concurrency_Strategy<SVC_HANDLER> (flags),
  90     reactor_ (0),
  91     mask_ (ACE_Event_Handler::NULL_MASK)
  92 {
  93   ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy");
  94 }
  95
  96 template <class SVC_HANDLER> ACE_INLINE
  97 ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy (ACE_Thread_Manager *thr_mgr,
  98                                                        long thr_flags,
  99                                                        int n_threads,
 100                                                        int flags)
 101 {
 102   ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy");
 103
 104   if (this->open (thr_mgr,
 105                   thr_flags,
 106                   n_threads,
 107                   flags) == -1)
 108     ACE_ERROR ((LM_ERROR,
 109                 ACE_TEXT ("%p\n"),
 110                 ACE_TEXT ("ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy")));
 111 }
 112
 113 template <class SVC_HANDLER> ACE_INLINE
 114 ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy (int flags)
 115   : ACE_Concurrency_Strategy<SVC_HANDLER> (flags),
 116     thr_mgr_ (0),
 117     thr_flags_ (0),
 118     n_threads_ (1)
 119 {
 120   ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy");
 121 }
 122
 123 template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_INLINE
 124 ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy (ACE_Reactor *reactor)
 125   : reactor_ (reactor)
 126 {
 127   ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy");
 128 }
 129
 130 template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_INLINE
 131 ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connect_Strategy (void)
 132 {
 133   ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connect_Strategy");
 134 }
 135
 136 template <class SVC_HANDLER> ACE_INLINE
 137 ACE_Process_Strategy<SVC_HANDLER>::ACE_Process_Strategy (size_t n_processes,
 138                                                          ACE_Event_Handler *acceptor,
 139                                                          ACE_Reactor *reactor,
 140                                                          int avoid_zombies)
 141 {
 142   ACE_TRACE ("ACE_Process_Strategy<SVC_HANDLER>::ACE_Process_Strategy");
 143   if (this->open (n_processes,
 144                   acceptor,
 145                   reactor,
 146                   avoid_zombies) == -1)
 147     ACE_ERROR ((LM_ERROR,
 148                 ACE_TEXT ("%p\n"),
 149                 ACE_TEXT ("ACE_Process_Strategy")));
 150 }
 151
 152 template <class SVC_HANDLER> ACE_INLINE
 153 ACE_Scheduling_Strategy<SVC_HANDLER>::ACE_Scheduling_Strategy (SVC_HANDLER *)
 154 {
 155   ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::ACE_Scheduling_Strategy");
 156 }
 157
 158 template <class SVC_HANDLER> ACE_INLINE
 159 ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::ACE_Schedule_All_Reactive_Strategy
 160   (SVC_HANDLER *scheduler)
 161   : ACE_Scheduling_Strategy<SVC_HANDLER> (scheduler)
 162 {
 163   ACE_TRACE ("ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::ACE_Schedule_All_Reactive_Strategy");
 164
 165   if (scheduler == 0 || scheduler->reactor () == 0)
 166     this->reactor_ = ACE_Reactor::instance ();
 167   else
 168     this->reactor_ = scheduler->reactor ();
 169 }
 170
 171 template <class SVC_HANDLER> ACE_INLINE
 172 ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::ACE_Schedule_All_Threaded_Strategy
 173   (SVC_HANDLER *scheduler)
 174   : ACE_Scheduling_Strategy<SVC_HANDLER> (scheduler)
 175 {
 176   ACE_TRACE ("ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::ACE_Schedule_All_Threaded_Strategy");
 177
 178   if (scheduler == 0 || scheduler->thr_mgr () == 0)
 179     this->thr_mgr_ = ACE_Thread_Manager::instance ();
 180   else
 181     this->thr_mgr_ = scheduler->thr_mgr ();
 182 }
 183
 184 template <class T> ACE_INLINE
 185 ACE_Refcounted_Hash_Recyclable<T>::ACE_Refcounted_Hash_Recyclable (void)
 186   : ACE_Refcountable (0),
 187     ACE_Hashable (),
 188     ACE_Recyclable (ACE_RECYCLABLE_UNKNOWN),
 189     t_ ()
 190 {
 191 }
 192
 193 template <class T> ACE_INLINE
 194 ACE_Refcounted_Hash_Recyclable<T>::ACE_Refcounted_Hash_Recyclable (const T &t,
 195                                                                    long refcount,
 196                                                                    ACE_Recyclable_State state)
 197   : ACE_Refcountable (refcount),
 198     ACE_Hashable (),
 199     ACE_Recyclable (state),
 200     t_ (t)
 201 {
 202 }
 203
 204 template <class T> ACE_INLINE u_long
 205 ACE_Refcounted_Hash_Recyclable<T>::hash_i (void) const
 206 {
 207   return this->t_.hash ();
 208 }
 209
 210 template <class T> ACE_INLINE T &
 211 ACE_Refcounted_Hash_Recyclable<T>::subject (void)
 212 {
 213   return this->t_;
 214 }
 215
 216 template <class T> ACE_INLINE bool
 217 ACE_Refcounted_Hash_Recyclable<T>::operator== (const ACE_Refcounted_Hash_Recyclable<T> &rhs) const
 218 {
 219   return
 220     this->recycle_state () == rhs.recycle_state ()
 221     && this->t_ == rhs.t_;
 222 }
 223
 224 template <class T> ACE_INLINE bool
 225 ACE_Refcounted_Hash_Recyclable<T>::operator!= (const ACE_Refcounted_Hash_Recyclable<T> &rhs) const
 226 {
 227   return !this->operator== (rhs);
 228 }
 229
 230 ACE_END_VERSIONED_NAMESPACE_DECL