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

ACE_Msg_WFMO_Reactor Class Reference

An OO event demultiplexor and event handler dispatcher for Win32 <MsgWaitForMultipleObjects>. More...

#include <Msg_WFMO_Reactor.h>

Inheritance diagram for ACE_Msg_WFMO_Reactor:

Inheritance graph
[legend]
Collaboration diagram for ACE_Msg_WFMO_Reactor:

Collaboration graph
[legend]
List of all members.

Public Methods

 ACE_Msg_WFMO_Reactor (ACE_Sig_Handler *=0, ACE_Timer_Queue *=0)
 Initialize <ACE_Msg_WFMO_Reactor> with the default size. More...

 ACE_Msg_WFMO_Reactor (size_t size, int unused=0, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0)
virtual ~ACE_Msg_WFMO_Reactor (void)
 Close down the ACE_Msg_WFMO_Reactor and release all of its resources. More...

virtual int handle_events (ACE_Time_Value *max_wait_time=0)
virtual int alertable_handle_events (ACE_Time_Value *max_wait_time=0)
virtual int handle_events (ACE_Time_Value &max_wait_time)
virtual int alertable_handle_events (ACE_Time_Value &max_wait_time)

Protected Methods

virtual DWORD wait_for_multiple_events (int timeout, int alertable)
 Wait for timer and I/O events to occur. More...

virtual DWORD poll_remaining_handles (DWORD index)
 Check for activity on remaining handles. More...

virtual int dispatch_window_messages (void)
 Dispatches window messages. More...


Detailed Description

An OO event demultiplexor and event handler dispatcher for Win32 <MsgWaitForMultipleObjects>.

The ACE_Msg_WFMO_Reactor is an OO event demultiplexor and event handler Reactor. It differs from <ACE_WFMO_Reactor> by its ability to react on Windows messages. It is needed when the task should serve also as a COM/DCOM server.

Definition at line 40 of file Msg_WFMO_Reactor.h.


Constructor & Destructor Documentation

ACE_Msg_WFMO_Reactor::ACE_Msg_WFMO_Reactor ACE_Sig_Handler   = 0,
ACE_Timer_Queue   = 0
 

Initialize <ACE_Msg_WFMO_Reactor> with the default size.

Definition at line 14 of file Msg_WFMO_Reactor.cpp.

00016   : ACE_WFMO_Reactor (sh, tq)
00017 {
00018 }

ACE_Msg_WFMO_Reactor::ACE_Msg_WFMO_Reactor size_t    size,
int    unused = 0,
ACE_Sig_Handler   = 0,
ACE_Timer_Queue   = 0
 

Initialize <ACE_Msg_WFMO_Reactor> with size <size>. Two slots will be added to the <size> parameter which will store handles used for internal management purposes.

Definition at line 20 of file Msg_WFMO_Reactor.cpp.

00024   : ACE_WFMO_Reactor (size, unused, sh, tq)
00025 {
00026 }

ACE_Msg_WFMO_Reactor::~ACE_Msg_WFMO_Reactor void    [virtual]
 

Close down the ACE_Msg_WFMO_Reactor and release all of its resources.

Definition at line 28 of file Msg_WFMO_Reactor.cpp.

00029 {
00030 }


Member Function Documentation

virtual int ACE_Msg_WFMO_Reactor::alertable_handle_events ACE_Time_Value   max_wait_time [virtual]
 

Reimplemented from ACE_WFMO_Reactor.

virtual int ACE_Msg_WFMO_Reactor::alertable_handle_events ACE_Time_Value   max_wait_time = 0 [virtual]
 

Reimplemented from ACE_WFMO_Reactor.

int ACE_Msg_WFMO_Reactor::dispatch_window_messages void    [protected, virtual]
 

Dispatches window messages.

Reimplemented from ACE_WFMO_Reactor.

Definition at line 58 of file Msg_WFMO_Reactor.cpp.

00059 {
00060   int number_of_messages = 0;
00061   MSG msg;
00062       
00063   // Process all pending message from this thread's message queue
00064   while (::PeekMessage (&msg, 0, 0, 0, PM_REMOVE))
00065     {
00066       ::TranslateMessage (&msg);
00067       if (msg.message == WM_QUIT)
00068         {
00069           // Should inform the main thread
00070           ::PostQuitMessage (msg.wParam); 
00071           return -1;
00072         }
00073       
00074       ::DispatchMessage (&msg);
00075       number_of_messages++;
00076     }
00077   
00078   return number_of_messages;
00079 }

virtual int ACE_Msg_WFMO_Reactor::handle_events ACE_Time_Value   max_wait_time [virtual]
 

This method is just like the one above, except the <max_wait_time> value is a reference and can therefore never be NULL.

Reimplemented from ACE_WFMO_Reactor.

virtual int ACE_Msg_WFMO_Reactor::handle_events ACE_Time_Value   max_wait_time = 0 [virtual]
 

This event loop driver blocks for up to <max_wait_time> before returning. It will return earlier if timer events, I/O events, window events, or signal events occur. Note that <max_wait_time> can be 0, in which case this method blocks indefinitely until events occur.

<max_wait_time> is decremented to reflect how much time this call took. For instance, if a time value of 3 seconds is passed to handle_events and an event occurs after 2 seconds, <max_wait_time> will equal 1 second. This can be used if an application wishes to handle events for some fixed amount of time.

<MsgWaitForMultipleObjects> is used as the demultiplexing call

Returns the total number of <ACE_Event_Handler>s that were dispatched, 0 if the <max_wait_time> elapsed without dispatching any handlers, or -1 if an error occurs.

The only difference between <alertable_handle_events> and <handle_events> is that in the alertable case, MWMO_ALERTABLE is passed to <MsgWaitForMultipleObjects> for the <bAlertable> option.

Reimplemented from ACE_WFMO_Reactor.

DWORD ACE_Msg_WFMO_Reactor::poll_remaining_handles DWORD    index [protected, virtual]
 

Check for activity on remaining handles.

Reimplemented from ACE_WFMO_Reactor.

Definition at line 82 of file Msg_WFMO_Reactor.cpp.

References ACE_WFMO_Reactor::handler_rep_, and ACE_WFMO_Reactor_Handler_Repository::handles.

00083 {
00084   return ::MsgWaitForMultipleObjects (this->handler_rep_.max_handlep1 () - slot,
00085                                       this->handler_rep_.handles () + slot,
00086                                       FALSE,
00087                                       0,
00088                                       QS_ALLINPUT);
00089 }

DWORD ACE_Msg_WFMO_Reactor::wait_for_multiple_events int    timeout,
int    alertable
[protected, virtual]
 

Wait for timer and I/O events to occur.

Reimplemented from ACE_WFMO_Reactor.

Definition at line 33 of file Msg_WFMO_Reactor.cpp.

References ACE_WFMO_Reactor::handler_rep_, and ACE_WFMO_Reactor_Handler_Repository::handles.

00035 {
00036   // Wait for any of handles_ to be active, or until timeout expires.
00037   // If <alertable> is enabled allow asynchronous completion of
00038   // ReadFile and WriteFile operations. QS_ALLINPUT allows
00039   // <MsgWaitForMultipleObjectsEx> to wait for any message is in the
00040   // queue.
00041 #if (defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0))
00042   return ::MsgWaitForMultipleObjectsEx (this->handler_rep_.max_handlep1 (),
00043                                         this->handler_rep_.handles (),
00044                                         timeout,
00045                                         QS_ALLINPUT,
00046                                         alertable);
00047 #else
00048   ACE_UNUSED_ARG (alertable);
00049   return ::MsgWaitForMultipleObjects (this->handler_rep_.max_handlep1 (),
00050                                       this->handler_rep_.handles (),
00051                                       FALSE,
00052                                       timeout,
00053                                       QS_ALLINPUT);
00054 #endif /* (defined (ACE_HAS_WINNT4) && (ACE_HAS_WINNT4 != 0)) */
00055 }


The documentation for this class was generated from the following files:
Generated on Mon Jun 16 12:50:46 2003 for ACE by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002