Go to the documentation of this file.00001
00002
00003
00004 #include "ace/Event_Handler.h"
00005 #include "ace/OS_Errno.h"
00006 #include "ace/Reactor.h"
00007 #include "ace/Thread_Manager.h"
00008
00009 #include "ace/Atomic_Op.h"
00010
00011 #if !defined (__ACE_INLINE__)
00012 #include "ace/Event_Handler.inl"
00013 #endif
00014
00015 #include <algorithm>
00016
00017 ACE_RCSID(ace, Event_Handler, "$Id: Event_Handler.cpp 85236 2009-05-01 11:43:56Z johnnyw $")
00018
00019 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00020
00021
00022
00023
00024 ACE_Event_Handler::ACE_Event_Handler (ACE_Reactor *r,
00025 int p)
00026 : reference_count_ (1),
00027 priority_ (p),
00028 reactor_ (r),
00029 reference_counting_policy_ (Reference_Counting_Policy::DISABLED)
00030 {
00031
00032 }
00033
00034 ACE_Event_Handler::~ACE_Event_Handler (void)
00035 {
00036
00037 }
00038
00039
00040
00041 ACE_HANDLE
00042 ACE_Event_Handler::get_handle (void) const
00043 {
00044 ACE_TRACE ("ACE_Event_Handler::get_handle");
00045 return ACE_INVALID_HANDLE;
00046 }
00047
00048
00049
00050 void
00051 ACE_Event_Handler::set_handle (ACE_HANDLE)
00052 {
00053 ACE_TRACE ("ACE_Event_Handler::set_handle");
00054 }
00055
00056
00057
00058 int
00059 ACE_Event_Handler::priority (void) const
00060 {
00061 ACE_TRACE ("ACE_Event_Handler::priority");
00062 return this->priority_;
00063 }
00064
00065
00066
00067 void
00068 ACE_Event_Handler::priority (int priority)
00069 {
00070 ACE_TRACE ("ACE_Event_Handler::priority");
00071 this->priority_ = priority;
00072 }
00073
00074
00075
00076
00077 int
00078 ACE_Event_Handler::handle_close (ACE_HANDLE, ACE_Reactor_Mask)
00079 {
00080 ACE_TRACE ("ACE_Event_Handler::handle_close");
00081 return -1;
00082 }
00083
00084
00085
00086 int
00087 ACE_Event_Handler::handle_input (ACE_HANDLE)
00088 {
00089 ACE_TRACE ("ACE_Event_Handler::handle_input");
00090 return -1;
00091 }
00092
00093
00094
00095 int
00096 ACE_Event_Handler::handle_output (ACE_HANDLE)
00097 {
00098 ACE_TRACE ("ACE_Event_Handler::handle_output");
00099 return -1;
00100 }
00101
00102
00103
00104 int
00105 ACE_Event_Handler::handle_exception (ACE_HANDLE)
00106 {
00107 ACE_TRACE ("ACE_Event_Handler::handle_exception");
00108 return -1;
00109 }
00110
00111
00112
00113 int
00114 ACE_Event_Handler::handle_timeout (const ACE_Time_Value &, const void *)
00115 {
00116 ACE_TRACE ("ACE_Event_Handler::handle_timeout");
00117 return -1;
00118 }
00119
00120
00121
00122 int
00123 ACE_Event_Handler::handle_exit (ACE_Process *)
00124 {
00125 ACE_TRACE ("ACE_Event_Handler::handle_exit");
00126 return -1;
00127 }
00128
00129
00130
00131 int
00132 ACE_Event_Handler::handle_signal (int, siginfo_t *, ucontext_t *)
00133 {
00134 ACE_TRACE ("ACE_Event_Handler::handle_signal");
00135 return -1;
00136 }
00137
00138 int
00139 ACE_Event_Handler::resume_handler (void)
00140 {
00141 ACE_TRACE ("ACE_Event_Handler::resume_handler");
00142
00143
00144
00145 return ACE_Event_Handler::ACE_REACTOR_RESUMES_HANDLER;
00146 }
00147
00148
00149 int
00150 ACE_Event_Handler::handle_qos (ACE_HANDLE)
00151 {
00152 ACE_TRACE ("ACE_Event_Handler::handle_qos");
00153 return -1;
00154 }
00155
00156 int
00157 ACE_Event_Handler::handle_group_qos (ACE_HANDLE)
00158 {
00159 ACE_TRACE ("ACE_Event_Handler::handle_group_qos");
00160 return -1;
00161 }
00162
00163 void
00164 ACE_Event_Handler::reactor (ACE_Reactor *reactor)
00165 {
00166 ACE_TRACE ("ACE_Event_Handler::reactor");
00167 this->reactor_ = reactor;
00168 }
00169
00170 ACE_Reactor *
00171 ACE_Event_Handler::reactor (void) const
00172 {
00173 ACE_TRACE ("ACE_Event_Handler::reactor");
00174 return this->reactor_;
00175 }
00176
00177 ACE_Reactor_Timer_Interface *
00178 ACE_Event_Handler::reactor_timer_interface (void) const
00179 {
00180 ACE_TRACE ("ACE_Event_Handler::reactor_timer_interface");
00181 return this->reactor_;
00182 }
00183
00184 ACE_Event_Handler::Reference_Count
00185 ACE_Event_Handler::add_reference (void)
00186 {
00187 bool const reference_counting_required =
00188 this->reference_counting_policy ().value () ==
00189 ACE_Event_Handler::Reference_Counting_Policy::ENABLED;
00190
00191 if (reference_counting_required)
00192 return ++this->reference_count_;
00193 else
00194 return 1;
00195 }
00196
00197 ACE_Event_Handler::Reference_Count
00198 ACE_Event_Handler::remove_reference (void)
00199 {
00200 bool const reference_counting_required =
00201 this->reference_counting_policy ().value () ==
00202 ACE_Event_Handler::Reference_Counting_Policy::ENABLED;
00203
00204 if (reference_counting_required)
00205 {
00206 Reference_Count result =
00207 --this->reference_count_;
00208
00209 if (result == 0)
00210 delete this;
00211
00212 return result;
00213 }
00214 else
00215 {
00216 return 1;
00217 }
00218 }
00219
00220 ACE_Event_Handler::Policy::~Policy (void)
00221 {
00222 }
00223
00224 ACE_Event_Handler::Reference_Counting_Policy::Reference_Counting_Policy (Reference_Counting_Policy::Value value)
00225 : value_ (value)
00226 {
00227 }
00228
00229 ACE_Event_Handler::Reference_Counting_Policy::Value
00230 ACE_Event_Handler::Reference_Counting_Policy::value (void) const
00231 {
00232 return this->value_;
00233 }
00234
00235 void
00236 ACE_Event_Handler::Reference_Counting_Policy::value (ACE_Event_Handler::Reference_Counting_Policy::Value value)
00237 {
00238 this->value_ = value;
00239 }
00240
00241 ACE_Event_Handler::Reference_Counting_Policy &
00242 ACE_Event_Handler::reference_counting_policy (void)
00243 {
00244 return this->reference_counting_policy_;
00245 }
00246
00247 ACE_THR_FUNC_RETURN
00248 ACE_Event_Handler::read_adapter (void *args)
00249 {
00250 ACE_Event_Handler *this_ptr = static_cast<ACE_Event_Handler *> (args);
00251 ACE_Reactor *r = this_ptr->reactor ();
00252
00253 while (this_ptr->handle_input (ACE_STDIN) != -1)
00254 continue;
00255
00256 this_ptr->handle_close (ACE_STDIN, ACE_Event_Handler::READ_MASK);
00257
00258
00259 r->notify ();
00260
00261 return 0;
00262 }
00263
00264 int
00265 ACE_Event_Handler::register_stdin_handler (ACE_Event_Handler *eh,
00266 ACE_Reactor *reactor,
00267 ACE_Thread_Manager *thr_mgr,
00268 int flags)
00269 {
00270 #if defined (ACE_WIN32)
00271 ACE_UNUSED_ARG (reactor);
00272
00273 eh->reactor (reactor);
00274 return thr_mgr->spawn (&read_adapter, static_cast<void *> (eh), flags);
00275 #else
00276
00277 ACE_UNUSED_ARG (flags);
00278 ACE_UNUSED_ARG (thr_mgr);
00279 return reactor->register_handler (ACE_STDIN,
00280 eh,
00281 ACE_Event_Handler::READ_MASK);
00282 #endif
00283 }
00284
00285 int
00286 ACE_Event_Handler::remove_stdin_handler (ACE_Reactor *reactor,
00287 ACE_Thread_Manager * )
00288 {
00289 #if defined (ACE_WIN32)
00290 ACE_UNUSED_ARG (reactor);
00291
00292
00293 ACE_NOTSUP_RETURN (-1);
00294 #else
00295 return reactor->remove_handler (ACE_STDIN,
00296 ACE_Event_Handler::READ_MASK);
00297 #endif
00298 }
00299
00300
00301
00302 ACE_Event_Handler_var::ACE_Event_Handler_var (void)
00303 : ptr_ (0)
00304 {
00305 }
00306
00307 ACE_Event_Handler_var::ACE_Event_Handler_var (ACE_Event_Handler *p)
00308 : ptr_ (p)
00309 {
00310 }
00311
00312 ACE_Event_Handler_var::ACE_Event_Handler_var (const ACE_Event_Handler_var &b)
00313 : ptr_ (b.ptr_)
00314 {
00315 if (this->ptr_ != 0)
00316 {
00317 this->ptr_->add_reference ();
00318 }
00319 }
00320
00321 ACE_Event_Handler_var::~ACE_Event_Handler_var (void)
00322 {
00323 if (this->ptr_ != 0)
00324 {
00325 ACE_Errno_Guard eguard (errno);
00326 this->ptr_->remove_reference ();
00327 }
00328 }
00329
00330 ACE_Event_Handler_var &
00331 ACE_Event_Handler_var::operator= (ACE_Event_Handler *p)
00332 {
00333 if (this->ptr_ != p)
00334 {
00335 ACE_Event_Handler_var tmp (p);
00336 std::swap (this->ptr_, tmp.ptr_);
00337 }
00338
00339 return *this;
00340 }
00341
00342 ACE_Event_Handler_var &
00343 ACE_Event_Handler_var::operator= (const ACE_Event_Handler_var &b)
00344 {
00345 ACE_Event_Handler_var tmp (b);
00346 std::swap (this->ptr_, tmp.ptr_);
00347
00348 return *this;
00349 }
00350
00351 ACE_Event_Handler *
00352 ACE_Event_Handler_var::operator->() const
00353 {
00354 return this->ptr_;
00355 }
00356
00357 ACE_Event_Handler *
00358 ACE_Event_Handler_var::handler (void) const
00359 {
00360 return this->ptr_;
00361 }
00362
00363 ACE_Event_Handler *
00364 ACE_Event_Handler_var::release (void)
00365 {
00366 ACE_Event_Handler * const old = this->ptr_;
00367 this->ptr_ = 0;
00368 return old;
00369 }
00370
00371 void
00372 ACE_Event_Handler_var::reset (ACE_Event_Handler *p)
00373 {
00374 *this = p;
00375 }
00376
00377
00378
00379 ACE_Notification_Buffer::ACE_Notification_Buffer (void)
00380 : eh_ (0),
00381 mask_ (ACE_Event_Handler::NULL_MASK)
00382 {
00383 ACE_TRACE ("ACE_Notification_Buffer::ACE_Notification_Buffer");
00384 }
00385
00386 ACE_Notification_Buffer::ACE_Notification_Buffer (ACE_Event_Handler *eh,
00387 ACE_Reactor_Mask mask)
00388 : eh_ (eh),
00389 mask_ (mask)
00390 {
00391 ACE_TRACE ("ACE_Notification_Buffer::ACE_Notification_Buffer");
00392 }
00393
00394 ACE_END_VERSIONED_NAMESPACE_DECL