#include <WFMO_Reactor.h>
Inheritance diagram for ACE_WFMO_Reactor:
Public Types | |
enum | { DEFAULT_SIZE = MAXIMUM_WAIT_OBJECTS - 2 } |
Public Methods | |
ACE_WFMO_Reactor (ACE_Sig_Handler *=0, ACE_Timer_Queue *=0) | |
Initialize <ACE_WFMO_Reactor> with the default size. More... | |
ACE_WFMO_Reactor (size_t size, int unused=0, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0) | |
Initialize <ACE_WFMO_Reactor> with size <size>. More... | |
virtual int | open (size_t size=ACE_WFMO_Reactor::DEFAULT_SIZE, int restart=0, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=0, ACE_Reactor_Notify *=0) |
Initialize <ACE_WFMO_Reactor> with size <size>. More... | |
virtual int | current_info (ACE_HANDLE, size_t &) |
Returns -1 (not used in this implementation);. More... | |
virtual int | set_sig_handler (ACE_Sig_Handler *signal_handler) |
Use a user specified signal handler instead. More... | |
virtual int | set_timer_queue (ACE_Timer_Queue *tq) |
| |
virtual int | timer_queue (ACE_Timer_Queue *tq) |
Set a user-specified timer queue. More... | |
virtual ACE_Timer_Queue * | timer_queue (void) const |
Return the current <ACE_Timer_Queue>. More... | |
virtual int | close (void) |
Close down the WFMO_Reactor and release all of its resources. More... | |
virtual | ~ACE_WFMO_Reactor (void) |
Close down the WFMO_Reactor and release all of its resources. More... | |
virtual int | work_pending (const ACE_Time_Value &max_wait_time=ACE_Time_Value::zero) |
This method is not currently implemented. More... | |
virtual int | handle_events (ACE_Time_Value *max_wait_time=0) |
This event loop driver blocks for up to <max_wait_time> before returning. More... | |
virtual int | alertable_handle_events (ACE_Time_Value *max_wait_time=0) |
virtual int | handle_events (ACE_Time_Value &max_wait_time) |
This method is just like the one above, except the <max_wait_time> value is a reference and can therefore never be NULL. More... | |
virtual int | alertable_handle_events (ACE_Time_Value &max_wait_time) |
virtual int | deactivated (void) |
Return the status of Reactor. More... | |
virtual void | deactivate (int do_stop) |
Control whether the Reactor will handle any more incoming events or not. More... | |
virtual int | register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle=ACE_INVALID_HANDLE) |
Register an <ACE_Event_Handler> <event_handler>. More... | |
virtual int | register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
Register an <ACE_Event_Handler> <event_handle>. More... | |
virtual int | register_handler (ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
This is a simple version of the above <register_handler> method where the I/O handle is passed in and the event handle will always be created by <WFMO_Reactor>. More... | |
virtual int | register_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
This is a simple version of the above <register_handler> method where the I/O handle will always come from <get_handle> on the <Event_Handler> and the event handle will always be created by <WFMO_Reactor>. More... | |
virtual int | register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
Register <event_handler> with all the <handles> in the <Handle_Set>. More... | |
virtual int | register_handler (int signum, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0, ACE_Event_Handler **old_sh=0, ACE_Sig_Action *old_disp=0) |
Register <new_sh> to handle the signal <signum> using the <new_dis. More... | |
virtual int | register_handler (const ACE_Sig_Set &sigset, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0) |
Registers <new_sh> to handle a set of signals <sigset> using the <new_disp>. More... | |
virtual int | remove_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
Removes <event_handler> from the <ACE_WFMO_Reactor>. More... | |
virtual int | remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask mask) |
Removes <handle> from the <ACE_WFMO_Reactor>. More... | |
virtual int | remove_handler (const ACE_Handle_Set &handle_set, ACE_Reactor_Mask) |
Removes all the <mask> bindings for handles in the <handle_set> bind of <Event_Handler>. More... | |
virtual int | remove_handler (int signum, ACE_Sig_Action *new_disp, ACE_Sig_Action *old_disp=0, int sigkey=-1) |
Remove the ACE_Event_Handler currently associated with <signum>. More... | |
virtual int | remove_handler (const ACE_Sig_Set &sigset) |
Calls <remove_handler> for every signal in <sigset>. More... | |
virtual int | suspend_handler (ACE_Event_Handler *event_handler) |
Suspend <event_handler> temporarily. Use <ACE_Event_Handler::get_handle> to get the handle. More... | |
virtual int | suspend_handler (ACE_HANDLE handle) |
Suspend <handle> temporarily. More... | |
virtual int | suspend_handler (const ACE_Handle_Set &handles) |
Suspend all <handles> in handle set temporarily. More... | |
virtual int | suspend_handlers (void) |
Suspend all <handles> temporarily. More... | |
virtual int | resume_handler (ACE_Event_Handler *event_handler) |
Resume <event_handler>. Use <ACE_Event_Handler::get_handle> to get the handle. More... | |
virtual int | resume_handler (ACE_HANDLE handle) |
Resume <handle>. More... | |
virtual int | resume_handler (const ACE_Handle_Set &handles) |
Resume all <handles> in handle set. More... | |
virtual int | resume_handlers (void) |
Resume all <handles>. More... | |
virtual int | resumable_handler (void) |
Does the reactor allow the application to resume the handle on its own ie. can it pass on the control of handle resumption to the application. A positive value indicates that the handlers are application resumable. A value of 0 indicates otherwise. More... | |
virtual int | uses_event_associations (void) |
Return 1 if we any event associations were made by the reactor for the handles that it waits on, 0 otherwise. More... | |
virtual long | schedule_timer (ACE_Event_Handler *event_handler, const void *arg, const ACE_Time_Value &delay, const ACE_Time_Value &interval=ACE_Time_Value::zero) |
Schedule an ACE_Event_Handler that will expire after an amount of time. More... | |
virtual int | reset_timer_interval (long timer_id, const ACE_Time_Value &interval) |
Resets the interval of the timer represented by <timer_id> to <interval>, which is specified in relative time to the current <gettimeofday>. More... | |
virtual int | cancel_timer (ACE_Event_Handler *event_handler, int dont_call_handle_close=1) |
Cancel all Event_Handlers that match the address of <event_handler>. Returns number of handler's cancelled. More... | |
virtual int | cancel_timer (long timer_id, const void **arg=0, int dont_call_handle_close=1) |
Cancel the single Event_Handler that matches the <timer_id> value (which was returned from the schedule method). More... | |
virtual int | schedule_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_added) |
Add <masks_to_be_added> to the <event_handler>'s entry in WFMO_Reactor. More... | |
virtual int | schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added) |
Add <masks_to_be_added> to the <handle>'s entry in WFMO_Reactor. More... | |
virtual int | cancel_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_deleted) |
Remove <masks_to_be_deleted> to the <handle>'s entry in WFMO_Reactor. More... | |
virtual int | cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_deleted) |
Remove <masks_to_be_deleted> to the <handle>'s entry in WFMO_Reactor. More... | |
virtual int | notify (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *=0) |
Wakeup one <ACE_WFMO_Reactor> thread if it is currently blocked in <WaitForMultipleObjects>. More... | |
virtual void | max_notify_iterations (int) |
Set the maximum number of times that the <ACE_WFMO_Reactor_Notify::handle_input> method will iterate and dispatch the <ACE_Event_Handlers> that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop. More... | |
virtual int | max_notify_iterations (void) |
Get the maximum number of times that the <ACE_WFMO_Reactor_Notify::handle_input> method will iterate and dispatch the <ACE_Event_Handlers> that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop. More... | |
virtual int | purge_pending_notifications (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK) |
Purge any notifications pending in this reactor for the specified <ACE_Event_Handler> object. More... | |
virtual int | handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler=0) |
Check to see if <handle> is associated with a valid Event_Handler bound to <mask>. More... | |
virtual int | handler (int signum, ACE_Event_Handler **=0) |
Check to see if <signum> is associated with a valid Event_Handler bound to a signal. More... | |
virtual int | initialized (void) |
Returns true if WFMO_Reactor has been successfully initialized, else false. More... | |
virtual size_t | size (void) const |
Returns the current size of the WFMO_Reactor's internal descriptor table. More... | |
virtual ACE_Lock & | lock (void) |
Returns a reference to the WFMO_Reactor's internal lock. More... | |
virtual void | wakeup_all_threads (void) |
Wake up all threads in WaitForMultipleObjects so that they can reconsult the handle set. More... | |
virtual int | owner (ACE_thread_t new_owner, ACE_thread_t *old_owner=0) |
Transfers ownership of the WFMO_Reactor to the <new_owner>. More... | |
virtual int | owner (ACE_thread_t *owner) |
Return the ID of the "owner" thread. More... | |
virtual int | restart (void) |
Get the existing restart value. More... | |
virtual int | restart (int r) |
Set a new value for restart and return the original value. More... | |
virtual void | requeue_position (int) |
Not implemented. More... | |
virtual int | requeue_position (void) |
Not implemented. More... | |
virtual int | mask_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks, int operation) |
Modify <masks> of the <event_handler>'s entry in WFMO_Reactor depending upon <operation>. More... | |
virtual int | mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask masks, int ops) |
Modify <masks> of the <handle>'s entry in WFMO_Reactor depending upon <operation>. More... | |
virtual int | ready_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops) |
Not implemented. More... | |
virtual int | ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask, int ops) |
Not implemented. More... | |
virtual void | dump (void) const |
Dump the state of an object. More... | |
Public Attributes | |
ACE_ALLOC_HOOK_DECLARE | |
Declare the dynamic allocation hooks. More... | |
Protected Methods | |
virtual int | register_handler_i (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) |
Registration workhorse. More... | |
virtual int | event_handling (ACE_Time_Value *max_wait_time=0, int alertable=0) |
Event handling workhorse. More... | |
virtual int | mask_ops_i (ACE_HANDLE io_handle, ACE_Reactor_Mask masks, int operation) |
Bit masking workhorse. More... | |
virtual ACE_thread_t | owner_i (void) |
Return the ID of the "owner" thread. Does not do any locking. More... | |
virtual int | ok_to_wait (ACE_Time_Value *max_wait_time, int alertable) |
Check to see if it is ok to enter <WaitForMultipleObjects>. More... | |
virtual int | wait_for_multiple_events (int timeout, int alertable) |
Wait for timer and I/O events to occur. More... | |
virtual DWORD | poll_remaining_handles (size_t slot) |
Check for activity on remaining handles. More... | |
virtual int | expire_timers (void) |
Expire timers. Only the owner thread does useful stuff in this function. More... | |
virtual int | dispatch (int wait_status) |
Dispatches the timers and I/O handlers. More... | |
virtual int | safe_dispatch (int wait_status) |
Protect against structured exceptions caused by user code when dispatching handles. More... | |
virtual int | dispatch_handles (size_t slot) |
Dispatches any active handles from handles_[<slot>] to handles_[active_handles_] using <WaitForMultipleObjects> to poll through our handle set looking for active handles. More... | |
virtual int | dispatch_handler (size_t slot, size_t max_handlep1) |
Dispatches a single handler. Returns 0 on success, -1 if the handler was removed. More... | |
virtual int | simple_dispatch_handler (int slot, ACE_HANDLE event_handle) |
Dispatches a single handler. Returns 0 on success, -1 if the handler was removed. More... | |
virtual int | complex_dispatch_handler (int slot, ACE_HANDLE event_handle) |
Dispatches a single handler. Returns 0 on success, -1 if the handler was removed. More... | |
virtual int | dispatch_window_messages (void) |
Dispatches window messages. Noop for WFMO_Reactor. More... | |
virtual ACE_Reactor_Mask | upcall (ACE_Event_Handler *event_handler, ACE_HANDLE io_handle, WSANETWORKEVENTS &events) |
virtual int | calculate_timeout (ACE_Time_Value *time) |
Used to caluculate the next timeout. More... | |
virtual int | update_state (void) |
Update the state of the handler repository. More... | |
virtual int | new_owner (void) |
Check to see if we have a new owner. More... | |
virtual int | change_owner (void) |
Set owner to new owner. More... | |
Protected Attributes | |
ACE_Sig_Handler * | signal_handler_ |
Handle signals without requiring global/static variables. More... | |
int | delete_signal_handler_ |
Keeps track of whether we should delete the signal handler (if we didn't create it, then we don't delete it). More... | |
ACE_Timer_Queue * | timer_queue_ |
Defined as a pointer to allow overriding by derived classes... More... | |
int | delete_timer_queue_ |
Keeps track of whether we should delete the timer queue (if we didn't create it, then we don't delete it). More... | |
int | delete_handler_rep_ |
Keeps track of whether we should delete the handler repository. More... | |
ACE_Reactor_Notify * | notify_handler_ |
Used when <notify> is called. More... | |
int | delete_notify_handler_ |
Keeps track of whether we should delete the notify handler. More... | |
ACE_Process_Mutex | lock_ |
Synchronization for the ACE_WFMO_Reactor. More... | |
ACE_Lock_Adapter< ACE_Process_Mutex > | lock_adapter_ |
Adapter used to return internal lock to outside world. More... | |
ACE_WFMO_Reactor_Handler_Repository | handler_rep_ |
Table that maps <ACE_HANDLEs> to <ACE_Event_Handler *>'s. More... | |
ACE_Manual_Event | ok_to_wait_ |
A manual event used to block threads from proceeding into WaitForMultipleObjects. More... | |
ACE_Manual_Event | wakeup_all_threads_ |
A manual event is used so that we can wake everyone up (e.g., when <ACE_Event_Handlers> are bounded and unbound from the handler repository). More... | |
ACE_Wakeup_All_Threads_Handler | wakeup_all_threads_handler_ |
Used when <wakeup_all_threads_> is signaled. More... | |
ACE_Auto_Event | waiting_to_change_state_ |
The changing thread waits on this event, till all threads are not active anymore. More... | |
size_t | active_threads_ |
Count of currently active threads. More... | |
ACE_thread_t | owner_ |
The thread which is "owner" of the WFMO_Reactor. More... | |
ACE_thread_t | new_owner_ |
The owner to be of the WFMO_Reactor. More... | |
ACE_thread_t | change_state_thread_ |
This is the thread which is responsible for the changing the state of the <WFMO_Reactor> handle set. More... | |
ACE_HANDLE | atomic_wait_array_ [2] |
This is an array of ACE_HANDLEs which keep track of the <lock_> and <ok_to_wait_> handles. More... | |
int | open_for_business_ |
This flag is used to keep track of whether we are already closed. More... | |
sig_atomic_t | deactivated_ |
This flag is used to keep track of whether we are actively handling events or not. More... | |
Private Methods | |
ACE_WFMO_Reactor (const ACE_WFMO_Reactor &) | |
Deny access since member-wise won't work... More... | |
ACE_WFMO_Reactor & | operator= (const ACE_WFMO_Reactor &) |
Friends | |
class | ACE_WFMO_Reactor_Handler_Repository |
class | ACE_WFMO_Reactor_Test |
The ACE_WFMO_Reactor is an object-oriented event demultiplexor and event handler Reactor. The sources of events that the ACE_WFMO_Reactor waits for and dispatches includes I/O events, general Win32 synchronization events (such as mutexes, semaphores, threads, etc.) and timer events. Note that changes to the state of WFMO_Reactor are not instantaneous. Most changes (registration, removal, suspension, and resumption of handles, and changes in ownership) are made when the WFMO_Reactor reaches a stable state. Users should be careful, specially when removing handlers. This is because the WFMO_Reactor will call handle_close on the handler when it is finally removed and not when remove_handler is called. If the handler is not going to be around when the WFMO_Reactor calls <ACE_Event_Handler::handle_close>, use the DONT_CALL flag with <remove_handler>. Or else, dynamically allocate the handler, and then call "delete this" inside <ACE_Event_Handler::handle_close>.
|
|
|
Initialize <ACE_WFMO_Reactor> with the default size.
|
|
Initialize <ACE_WFMO_Reactor> with size <size>. <size> should not exceed <ACE_WFMO_Reactor::DEFAULT_SIZE>. Two slots will be added to the <size> parameter which will store handles used for internal management purposes. |
|
Close down the WFMO_Reactor and release all of its resources.
|
|
Deny access since member-wise won't work...
|
|
Reimplemented from ACE_Reactor_Impl. Reimplemented in ACE_Msg_WFMO_Reactor. |
|
Reimplemented from ACE_Reactor_Impl. Reimplemented in ACE_Msg_WFMO_Reactor. |
|
Used to caluculate the next timeout.
|
|
Cancel the single Event_Handler that matches the <timer_id> value (which was returned from the schedule method). If arg is non-NULL then it will be set to point to the ``magic cookie'' argument passed in when the Event_Handler was registered. This makes it possible to free up the memory and avoid memory leaks. Returns 1 if cancellation succeeded and 0 if the <timer_id> wasn't found. Reimplemented from ACE_Reactor_Impl. |
|
Cancel all Event_Handlers that match the address of <event_handler>. Returns number of handler's cancelled.
Reimplemented from ACE_Reactor_Impl. |
|
Remove <masks_to_be_deleted> to the <handle>'s entry in WFMO_Reactor. The Event_Handler associated with <handle> must already have been registered with WFMO_Reactor. Reimplemented from ACE_Reactor_Impl. |
|
Remove <masks_to_be_deleted> to the <handle>'s entry in WFMO_Reactor. The Event_Handler associated with <handle> must already have been registered with WFMO_Reactor. Reimplemented from ACE_Reactor_Impl. |
|
Set owner to new owner.
|
|
Close down the WFMO_Reactor and release all of its resources.
Reimplemented from ACE_Reactor_Impl. |
|
Dispatches a single handler. Returns 0 on success, -1 if the handler was removed.
|
|
Returns -1 (not used in this implementation);.
Reimplemented from ACE_Reactor_Impl. |
|
Control whether the Reactor will handle any more incoming events or not. If <do_stop> == 1, the Reactor will be disabled. By default, a reactor is in active state and can be deactivated/reactived as wish. Reimplemented from ACE_Reactor_Impl. |
|
Return the status of Reactor. If this function returns 0, the reactor is actively handling events. If it returns non-zero, <handling_events> and <handle_alertable_events> return -1 immediately. Reimplemented from ACE_Reactor_Impl. |
|
Dispatches the timers and I/O handlers.
|
|
Dispatches a single handler. Returns 0 on success, -1 if the handler was removed.
|
|
Dispatches any active handles from handles_[<slot>] to handles_[active_handles_] using <WaitForMultipleObjects> to poll through our handle set looking for active handles.
|
|
Dispatches window messages. Noop for WFMO_Reactor.
Reimplemented in ACE_Msg_WFMO_Reactor. |
|
Dump the state of an object.
Reimplemented from ACE_Reactor_Impl. |
|
Event handling workhorse.
|
|
Expire timers. Only the owner thread does useful stuff in this function.
|
|
This method is just like the one above, except the <max_wait_time> value is a reference and can therefore never be NULL. The only difference between <alertable_handle_events> and <handle_events> is that in the alertable case, TRUE is passed to <WaitForMultipleObjects> for the <bAlertable> option. Reimplemented from ACE_Reactor_Impl. Reimplemented in ACE_Msg_WFMO_Reactor. |
|
This event loop driver blocks for up to <max_wait_time> before returning. It will return earlier if timer events, I/O 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. <WaitForMultipleObjects> is used as the demultiplexing call Returns the total number of I/O and timer <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, TRUE is passed to <WaitForMultipleObjects> for the <bAlertable> option. Reimplemented from ACE_Reactor_Impl. Reimplemented in ACE_Msg_WFMO_Reactor. |
|
Check to see if <signum> is associated with a valid Event_Handler bound to a signal. Return the <event_handler> associated with this <handler> if <event_handler> != 0. Reimplemented from ACE_Reactor_Impl. |
|
Check to see if <handle> is associated with a valid Event_Handler bound to <mask>. Return the <event_handler> associated with this <handler> if <event_handler> != 0. Reimplemented from ACE_Reactor_Impl. |
|
Returns true if WFMO_Reactor has been successfully initialized, else false.
Reimplemented from ACE_Reactor_Impl. |
|
Returns a reference to the WFMO_Reactor's internal lock.
Reimplemented from ACE_Reactor_Impl. |
|
Modify <masks> of the <handle>'s entry in WFMO_Reactor depending upon <operation>. <handle> must already have been registered with WFMO_Reactor. Reimplemented from ACE_Reactor_Impl. |
|
Modify <masks> of the <event_handler>'s entry in WFMO_Reactor depending upon <operation>. <event_handler> must already have been registered with WFMO_Reactor. Reimplemented from ACE_Reactor_Impl. |
|
Bit masking workhorse.
|
|
Get the maximum number of times that the <ACE_WFMO_Reactor_Notify::handle_input> method will iterate and dispatch the <ACE_Event_Handlers> that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop.
Reimplemented from ACE_Reactor_Impl. |
|
Set the maximum number of times that the <ACE_WFMO_Reactor_Notify::handle_input> method will iterate and dispatch the <ACE_Event_Handlers> that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop. By default, this is set to -1, which means "iterate until the queue is empty." Setting this to a value like "1 or 2" will increase "fairness" (and thus prevent starvation) at the expense of slightly higher dispatching overhead. Reimplemented from ACE_Reactor_Impl. |
|
Check to see if we have a new owner.
|
|
Wakeup one <ACE_WFMO_Reactor> thread if it is currently blocked in <WaitForMultipleObjects>. The <ACE_Time_Value> indicates how long to blocking trying to notify the <WFMO_Reactor>. If <timeout> == 0, the caller will block until action is possible, else will wait until the relative time specified in <timeout> elapses). Reimplemented from ACE_Reactor_Impl. |
|
Check to see if it is ok to enter <WaitForMultipleObjects>.
|
|
Initialize <ACE_WFMO_Reactor> with size <size>. <size> should not exceed <ACE_WFMO_Reactor::DEFAULT_SIZE>. Two slots will be added to the <size> parameter which will store handles used for internal management purposes. Reimplemented from ACE_Reactor_Impl. |
|
|
|
Return the ID of the "owner" thread.
Reimplemented from ACE_Reactor_Impl. |
|
Transfers ownership of the WFMO_Reactor to the <new_owner>. The transfer will not complete until all threads are ready (just like the handle set). Reimplemented from ACE_Reactor_Impl. |
|
Return the ID of the "owner" thread. Does not do any locking.
|
|
Check for activity on remaining handles.
Reimplemented in ACE_Msg_WFMO_Reactor. |
|
Purge any notifications pending in this reactor for the specified <ACE_Event_Handler> object. Returns the number of notifications purged. Returns -1 on error. Reimplemented from ACE_Reactor_Impl. |
|
Not implemented.
Reimplemented from ACE_Reactor_Impl. |
|
Not implemented.
Reimplemented from ACE_Reactor_Impl. |
|
Registers <new_sh> to handle a set of signals <sigset> using the <new_disp>.
Reimplemented from ACE_Reactor_Impl. |
|
Register <new_sh> to handle the signal <signum> using the <new_dis. p>. Returns the <old_sh> that was previously registered (if any), along with the <old_disp> of the signal handler. Reimplemented from ACE_Reactor_Impl. |
|
Register <event_handler> with all the <handles> in the <Handle_Set>.
Reimplemented from ACE_Reactor_Impl. |
|
This is a simple version of the above <register_handler> method where the I/O handle will always come from <get_handle> on the <Event_Handler> and the event handle will always be created by <WFMO_Reactor>.
Reimplemented from ACE_Reactor_Impl. |
|
This is a simple version of the above <register_handler> method where the I/O handle is passed in and the event handle will always be created by <WFMO_Reactor>.
Reimplemented from ACE_Reactor_Impl. |
|
Register an <ACE_Event_Handler> <event_handle>. <mask> specifies the network events that the <event_handler> is interested in. If <io_handle> == <ACE_INVALID_HANDLE> the <ACE_WFMO_Reactor> will call the <get_handle> method of <event_handler> to extract the underlying I/O handle. If the <event_handle> == <ACE_INVALID_HANDLE>, WFMO_Reactor will create an event for associating it with the I/O handle. When the <event_handle> is signalled, the appropriate <handle_*> callback will be invoked on the <Event_Handler> Reimplemented from ACE_Reactor_Impl. |
|
Register an <ACE_Event_Handler> <event_handler>. Since no Event Mask is passed through this interface, it is assumed that the <handle> being passed in is an event handle and when the event becomes signaled, <WFMO_Reactor> will call handle_signal on <event_handler>. If <handle> == <ACE_INVALID_HANDLE> the <ACE_WFMO_Reactor> will call the <get_handle> method of <event_handler> to extract the underlying event handle. Reimplemented from ACE_Reactor_Impl. |
|
Registration workhorse.
|
|
Calls <remove_handler> for every signal in <sigset>.
Reimplemented from ACE_Reactor_Impl. |
|
Remove the ACE_Event_Handler currently associated with <signum>. <sigkey> is ignored in this implementation since there is only one instance of a signal handler. Install the new disposition (if given) and return the previous disposition (if desired by the caller). Returns 0 on success and -1 if <signum> is invalid. Reimplemented from ACE_Reactor_Impl. |
|
Removes all the <mask> bindings for handles in the <handle_set> bind of <Event_Handler>. If there are no more bindings for any of these handles then they are removed from WFMO_Reactor. Reimplemented from ACE_Reactor_Impl. |
|
Removes <handle> from the <ACE_WFMO_Reactor>. If <mask> == <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of the <event_handler> is not invoked. Note that the <handle> can either be the <event_handle> or the <io_handle> For the case of I/O entries, this removes the <mask> binding of <Event_Handler> whose handle is <handle> from <WFMO_Reactor>. If there are no more bindings for this <event_handler> then it is removed from the WFMO_Reactor. For simple event entries, mask is mostly ignored and the <Event_Handler> is always removed from <WFMO_Reactor> Reimplemented from ACE_Reactor_Impl. |
|
Removes <event_handler> from the <ACE_WFMO_Reactor>. Note that the <ACE_WFMO_Reactor> will call the <get_handle> method of <event_handler> to extract the underlying handle. If <mask> == <ACE_Event_Handler::DONT_CALL> then the <handle_close> method of the <event_handler> is not invoked. Note that the <handle> can either be the <event_handle> or the <io_handle> Reimplemented from ACE_Reactor_Impl. |
|
Not implemented.
Reimplemented from ACE_Reactor_Impl. |
|
Not implemented.
Reimplemented from ACE_Reactor_Impl. |
|
Resets the interval of the timer represented by <timer_id> to <interval>, which is specified in relative time to the current <gettimeofday>. If <interval> is equal to <ACE_Time_Value::zero>, the timer will become a non-rescheduling timer. Returns 0 if successful, -1 if not. Reimplemented from ACE_Reactor_Impl. |
|
Set a new value for restart and return the original value.
Reimplemented from ACE_Reactor_Impl. |
|
Get the existing restart value.
Reimplemented from ACE_Reactor_Impl. |
|
Does the reactor allow the application to resume the handle on its own ie. can it pass on the control of handle resumption to the application. A positive value indicates that the handlers are application resumable. A value of 0 indicates otherwise.
Reimplemented from ACE_Reactor_Impl. |
|
Resume all <handles> in handle set.
Reimplemented from ACE_Reactor_Impl. |
|
Resume <handle>.
Reimplemented from ACE_Reactor_Impl. |
|
Resume <event_handler>. Use <ACE_Event_Handler::get_handle> to get the handle.
Reimplemented from ACE_Reactor_Impl. |
|
Resume all <handles>.
Reimplemented from ACE_Reactor_Impl. |
|
Protect against structured exceptions caused by user code when dispatching handles.
|
|
Schedule an ACE_Event_Handler that will expire after an amount of time. The return value of this method, a timer_id value, uniquely identifies the event_handler in the ACE_Reactor's internal list of timers. This timer_id value can be used to cancel the timer with the cancel_timer() call.
Reimplemented from ACE_Reactor_Impl. |
|
Add <masks_to_be_added> to the <handle>'s entry in WFMO_Reactor. The Event_Handler associated with <handle> must already have been registered with WFMO_Reactor. Reimplemented from ACE_Reactor_Impl. |
|
Add <masks_to_be_added> to the <event_handler>'s entry in WFMO_Reactor. <event_handler> must already have been registered with WFMO_Reactor. Reimplemented from ACE_Reactor_Impl. |
|
Use a user specified signal handler instead.
Reimplemented from ACE_Reactor_Impl. |
|
Reimplemented from ACE_Reactor_Impl. |
|
Dispatches a single handler. Returns 0 on success, -1 if the handler was removed.
|
|
Returns the current size of the WFMO_Reactor's internal descriptor table.
Reimplemented from ACE_Reactor_Impl. |
|
Suspend all <handles> in handle set temporarily.
Reimplemented from ACE_Reactor_Impl. |
|
Suspend <handle> temporarily.
Reimplemented from ACE_Reactor_Impl. |
|
Suspend <event_handler> temporarily. Use <ACE_Event_Handler::get_handle> to get the handle.
Reimplemented from ACE_Reactor_Impl. |
|
Suspend all <handles> temporarily.
Reimplemented from ACE_Reactor_Impl. |
|
Return the current <ACE_Timer_Queue>.
Reimplemented from ACE_Reactor_Impl. |
|
Set a user-specified timer queue.
Reimplemented from ACE_Reactor_Impl. |
|
|
|
Update the state of the handler repository.
|
|
Return 1 if we any event associations were made by the reactor for the handles that it waits on, 0 otherwise. Since the WFMO_Reactor does use event associations, this function always return 1. Reimplemented from ACE_Reactor_Impl. |
|
Wait for timer and I/O events to occur.
Reimplemented in ACE_Msg_WFMO_Reactor. |
|
Wake up all threads in WaitForMultipleObjects so that they can reconsult the handle set.
Reimplemented from ACE_Reactor_Impl. |
|
This method is not currently implemented. We recommend that you use handle_events (ACE_Time_Value::zero) to get basically the same effect, i.e., it won't block the caller if there are no events. Reimplemented from ACE_Reactor_Impl. |
|
|
|
|
|
Declare the dynamic allocation hooks.
Reimplemented from ACE_Reactor_Impl. |
|
Count of currently active threads.
|
|
This is an array of ACE_HANDLEs which keep track of the <lock_> and <ok_to_wait_> handles.
|
|
This is the thread which is responsible for the changing the state of the <WFMO_Reactor> handle set.
|
|
This flag is used to keep track of whether we are actively handling events or not.
|
|
Keeps track of whether we should delete the handler repository.
|
|
Keeps track of whether we should delete the notify handler.
|
|
Keeps track of whether we should delete the signal handler (if we didn't create it, then we don't delete it).
|
|
Keeps track of whether we should delete the timer queue (if we didn't create it, then we don't delete it).
|
|
Table that maps <ACE_HANDLEs> to <ACE_Event_Handler *>'s.
|
|
Synchronization for the ACE_WFMO_Reactor. A Process Mutex is used here because of two reasons: (a) The implementation of ACE_Thread_Mutex uses CriticalSections CriticalSections are not waitable using WaitForMultipleObjects (b) This is really not a process mutex because it is not named. No other process can use this mutex. |
|
Adapter used to return internal lock to outside world.
|
|
The owner to be of the WFMO_Reactor.
|
|
Used when <notify> is called.
|
|
A manual event used to block threads from proceeding into WaitForMultipleObjects.
|
|
This flag is used to keep track of whether we are already closed.
|
|
The thread which is "owner" of the WFMO_Reactor. The owner concept is used because we don't want multiple threads to try to expire timers. Therefore the "owner" thread is the only one allowed to expire timers. Also, the owner thread is the only thread which waits on the notify handle. Note that the ownership can be transferred. |
|
Handle signals without requiring global/static variables.
|
|
Defined as a pointer to allow overriding by derived classes...
|
|
The changing thread waits on this event, till all threads are not active anymore.
|
|
A manual event is used so that we can wake everyone up (e.g., when <ACE_Event_Handlers> are bounded and unbound from the handler repository).
|
|
Used when <wakeup_all_threads_> is signaled.
|