A base class for wrappers around the Win32 event locking mechanism. More...
|Implicitly destroy the event variable. More...|
|ACE_event_t||handle (void) const|
|Underlying handle to event. More...|
|void||handle (ACE_event_t new_handle)|
|int||wait (const ACE_Time_Value *abstime, int use_absolute_time=1)|
|Set to nonsignaled state. More...|
|void||dump (void) const|
|Dump the state of an object. More...|
|Declare the dynamic allocation hooks. More...|
|Only derived classes allowed to construct event. More...|
|The underlying handle. More...|
|ACE_Event_Base (const ACE_Event_Base &event)|
|const ACE_Event_Base &||operator= (const ACE_Event_Base &rhs)|
A base class for wrappers around the Win32 event locking mechanism.
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.
Implicitly destroy the event variable.
Only derived classes allowed to construct event.
Dump the state of an object.
Underlying handle to event.
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.
if MANUAL reset wakeup all waiting threads and reset event else AUTO reset wakeup one waiting thread (if present) and reset event
Explicitly destroy the event variable. Note that only one thread should call this method since it doesn't protect against race conditions.
Set to nonsignaled state.
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
|int ACE_Event_Base::wait||(||const ACE_Time_Value *||abstime,|
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.
Declare the dynamic allocation hooks.
The underlying handle.
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...