Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages  

ACE_Event Class Reference

A wrapper around the Win32 event locking mechanism. More...

#include <Event.h>

Inheritance diagram for ACE_Event:

Inheritance graph
[legend]
List of all members.

Public Methods

 ACE_Event (int manual_reset=0, int initial_state=0, int type=USYNC_THREAD, const ACE_TCHAR *name=0, void *arg=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.

int removed_

Private Methods

 ACE_Event (const ACE_Event &event)
const ACE_Event & operator= (const ACE_Event &rhs)

Detailed Description

A wrapper 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.


Constructor & Destructor Documentation

ACE_Event::ACE_Event int    manual_reset = 0,
int    initial_state = 0,
int    type = USYNC_THREAD,
const ACE_TCHAR   name = 0,
void *    arg = 0
 

Constructor that creates event.

ACE_Event::~ACE_Event void   
 

Implicitly destroy the event variable.

ACE_Event::ACE_Event const ACE_Event &    event [private]
 


Member Function Documentation

void ACE_Event::dump void    const
 

Dump the state of an object.

Reimplemented in ACE_Auto_Event, and ACE_Manual_Event.

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.

ACE_INLINE ACE_event_t ACE_Event::handle void    const
 

Underlying handle to event.

const ACE_Event& ACE_Event::operator= const ACE_Event &    rhs [private]
 

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

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.

int ACE_Event::reset void   
 

Set to nonsignaled state.

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

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.

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.


Member Data Documentation

ACE_Event::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Reimplemented in ACE_Auto_Event, and ACE_Manual_Event.

ACE_event_t ACE_Event::handle_ [protected]
 

The underlying handle.

int 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...


The documentation for this class was generated from the following files:
Generated on Fri Apr 2 16:48:26 2004 for ACE by doxygen1.2.18