#include <Event.h>
Inheritance diagram for ACE_Event:
Public Member Functions | |
| ACE_Event (int manual_reset=0, int initial_state=0, int type=USYNC_THREAD, const ACE_TCHAR *name=0, void *arg=0, LPSECURITY_ATTRIBUTES sa=0) | |
| Constructor that creates event. | |
| ~ACE_Event (void) | |
| Implicitly destroy the event variable. | |
| int | remove (void) |
| ACE_event_t | handle (void) const |
| Underlying handle to event. | |
| void | handle (ACE_event_t new_handle) |
| int | wait (void) |
| int | wait (const ACE_Time_Value *abstime, int use_absolute_time=1) |
| int | signal (void) |
| int | pulse (void) |
| int | reset (void) |
| Set to nonsignaled state. | |
| void | dump (void) const |
| Dump the state of an object. | |
Public Attributes | |
| ACE_ALLOC_HOOK_DECLARE | |
| Declare the dynamic allocation hooks. | |
Protected Attributes | |
| ACE_event_t | handle_ |
| The underlying handle. | |
| bool | removed_ |
Private Member Functions | |
| ACE_Event (const ACE_Event &event) | |
| const ACE_Event & | operator= (const ACE_Event &rhs) |
Portable implementation of an Event mechanism, which is native to Win32, but must be emulated on UNIX. All platforms support process-scope locking support. However, only Win32 platforms support global naming and system-scope locking support.
Definition at line 39 of file Event.h.
| ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_Event::ACE_Event | ( | int | manual_reset = 0, |
|
| int | initial_state = 0, |
|||
| int | type = USYNC_THREAD, |
|||
| const ACE_TCHAR * | name = 0, |
|||
| void * | arg = 0, |
|||
| LPSECURITY_ATTRIBUTES | sa = 0 | |||
| ) |
Constructor that creates event.
Definition at line 15 of file Event.cpp.
References ACE_ERROR, ACE_TEXT, ACE_OS::event_init(), and LM_ERROR.
00021 : removed_ (false) 00022 { 00023 if (ACE_OS::event_init (&this->handle_, 00024 manual_reset, 00025 initial_state, 00026 type, 00027 name, 00028 arg, 00029 sa) != 0) 00030 ACE_ERROR ((LM_ERROR, 00031 ACE_TEXT ("%p\n"), 00032 ACE_TEXT ("ACE_Event::ACE_Event"))); 00033 }
| ACE_Event::~ACE_Event | ( | void | ) |
| ACE_Event::ACE_Event | ( | const ACE_Event & | event | ) | [private] |
| void ACE_Event::dump | ( | void | ) | const |
Dump the state of an object.
Reimplemented in ACE_Auto_Event, and ACE_Manual_Event.
Definition at line 85 of file Event.cpp.
References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, and LM_DEBUG.
Referenced by ACE_Manual_Event::dump(), and ACE_Auto_Event::dump().
00086 { 00087 #if defined (ACE_HAS_DUMP) 00088 ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); 00089 ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); 00090 #endif /* ACE_HAS_DUMP */ 00091 }
| ACE_INLINE void ACE_Event::handle | ( | ACE_event_t | new_handle | ) |
Set the underlying handle to event. Note that this method assumes ownership of the <handle> and will close it down in <remove>. If you want the <handle> to stay open when <remove> is called make sure to call <dup> on the <handle> before closing it. You are responsible for the closing the existing <handle> before overwriting it.
Definition at line 13 of file Event.inl.
References handle_.
00014 { 00015 this->handle_ = new_handle; 00016 }
| ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_event_t ACE_Event::handle | ( | void | ) | const |
| int ACE_Event::pulse | ( | void | ) |
if MANUAL reset wakeup all waiting threads and reset event else AUTO reset wakeup one waiting thread (if present) and reset event
Definition at line 73 of file Event.cpp.
References ACE_OS::event_pulse().
00074 { 00075 return ACE_OS::event_pulse (&this->handle_); 00076 }
| int ACE_Event::remove | ( | void | ) |
Explicitly destroy the event variable. Note that only one thread should call this method since it doesn't protect against race conditions.
Definition at line 41 of file Event.cpp.
References ACE_OS::event_destroy(), and removed_.
Referenced by ~ACE_Event().
00042 { 00043 int result = 0; 00044 if (!this->removed_) 00045 { 00046 this->removed_ = true; 00047 result = ACE_OS::event_destroy (&this->handle_); 00048 } 00049 return result; 00050 }
| int ACE_Event::reset | ( | void | ) |
Set to nonsignaled state.
Definition at line 79 of file Event.cpp.
References ACE_OS::event_reset().
00080 { 00081 return ACE_OS::event_reset (&this->handle_); 00082 }
| int ACE_Event::signal | ( | void | ) |
if MANUAL reset wake up all waiting threads set to signaled state else AUTO reset if no thread is waiting, set to signaled state if thread(s) are waiting, wake up one waiting thread and reset event
Definition at line 67 of file Event.cpp.
References ACE_OS::event_signal().
00068 { 00069 return ACE_OS::event_signal (&this->handle_); 00070 }
| int ACE_Event::wait | ( | const ACE_Time_Value * | abstime, | |
| int | use_absolute_time = 1 | |||
| ) |
Same as wait() above, but this one can be timed abstime is absolute time-of-day if if use_absolute_time is non-0, else it is relative time.
Definition at line 59 of file Event.cpp.
References ACE_OS::event_timedwait().
00060 { 00061 return ACE_OS::event_timedwait (&this->handle_, 00062 const_cast <ACE_Time_Value *> (abstime), 00063 use_absolute_time); 00064 }
| int ACE_Event::wait | ( | void | ) |
if MANUAL reset sleep till the event becomes signaled event remains signaled after wait() completes. else AUTO reset sleep till the event becomes signaled event resets wait() completes.
Definition at line 53 of file Event.cpp.
References ACE_OS::event_wait().
00054 { 00055 return ACE_OS::event_wait (&this->handle_); 00056 }
ACE_event_t ACE_Event::handle_ [protected] |
bool ACE_Event::removed_ [protected] |
Keeps track of whether <remove> has been called yet to avoid multiple <remove> calls, e.g., explicitly and implicitly in the destructor. This flag isn't protected by a lock, so make sure that you don't have multiple threads simultaneously calling <remove> on the same object, which is a bad idea anyway...
Definition at line 128 of file Event.h.
Referenced by remove().
1.4.7