Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

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 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)

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.

Definition at line 39 of file Event.h.

Constructor & Destructor Documentation

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_TCHAR, 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   ) 
 

Implicitly destroy the event variable.

Definition at line 35 of file Event.cpp.

References remove(). 

00036 {
00037   this->remove ();
00038 }

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.

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 and will close it down in . If you want the to stay open when is called make sure to call on the before closing it. You are responsible for the closing the existing before overwriting it.

Definition at line 13 of file Event.inl. 

00014 {
00015   this->handle_ = new_handle;
00016 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_event_t ACE_Event::handle (  void   )  const
 

Underlying handle to event.

Definition at line 7 of file Event.inl. 

00008 {
00009   return this->handle_;
00010 }

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

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().

Referenced by ACE_Proactor_Timer_Handler::~ACE_Proactor_Timer_Handler(). 

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().

Referenced by ACE_Proactor_Timer_Handler::svc(). 

00054 {
00055   return ACE_OS::event_wait (&this->handle_);
00056 }

Member Data Documentation

ACE_Event::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Reimplemented in ACE_Auto_Event, and ACE_Manual_Event.

Definition at line 117 of file Event.h.

ACE_event_t ACE_Event::handle_ [protected]
 

The underlying handle.

Definition at line 121 of file Event.h.

bool ACE_Event::removed_ [protected]
 

Keeps track of whether has been called yet to avoid multiple 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 on the same object, which is a bad idea anyway...

Definition at line 128 of file Event.h.

Referenced by remove().

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 12:54:36 2008 for ACE by doxygen 1.3.6