ACE_WFMO_Reactor Class Reference

An object oriented event demultiplexor and event handler. ACE_WFMO_Reactor is a Windows-only implementation of the ACE_Reactor interface that uses the WaitForMultipleObjects() event demultiplexer. More...

#include <WFMO_Reactor.h>

Inheritance diagram for ACE_WFMO_Reactor:

Collaboration diagram for ACE_WFMO_Reactor:

List of all members.

Public Types
enum	{ DEFAULT_SIZE = MAXIMUM_WAIT_OBJECTS - 2 }
Public Member Functions
	ACE_WFMO_Reactor (ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, ACE_Reactor_Notify *=0)
	Initialize ACE_WFMO_Reactor with the default size.
	ACE_WFMO_Reactor (size_t size, int unused=0, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, ACE_Reactor_Notify *=0)
virtual int	open (size_t size=ACE_WFMO_Reactor::DEFAULT_SIZE, bool restart=false, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=0, ACE_Reactor_Notify *=0)
virtual int	current_info (ACE_HANDLE, size_t &)
	Returns -1 (not used in this implementation);.
virtual int	set_sig_handler (ACE_Sig_Handler *signal_handler)
	Use a user specified signal handler instead.
virtual int	timer_queue (ACE_Timer_Queue *tq)
	Set a user-specified timer queue.
virtual ACE_Timer_Queue *	timer_queue (void) const
	Return the current ACE_Timer_Queue.
virtual int	close (void)
	Close down the ACE_WFMO_Reactor and release all of its resources.
virtual	~ACE_WFMO_Reactor (void)
	Close down the ACE_WFMO_Reactor and release all of its resources.
virtual int	work_pending (const ACE_Time_Value &max_wait_time=ACE_Time_Value::zero)
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)
virtual int	deactivated (void)
virtual void	deactivate (int do_stop)
virtual int	register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle=ACE_INVALID_HANDLE)
virtual int	register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int	register_handler (ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int	register_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int	register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
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)
virtual int	register_handler (const ACE_Sig_Set &sigset, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=0)
virtual int	remove_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
virtual int	remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask mask)
virtual int	remove_handler (const ACE_Handle_Set &handle_set, ACE_Reactor_Mask)
virtual int	remove_handler (int signum, ACE_Sig_Action *new_disp, ACE_Sig_Action *old_disp=0, int sigkey=-1)
virtual int	remove_handler (const ACE_Sig_Set &sigset)
	Calls remove_handler() for every signal in sigset.
virtual int	suspend_handler (ACE_Event_Handler *event_handler)
virtual int	suspend_handler (ACE_HANDLE handle)
	Suspend handle temporarily.
virtual int	suspend_handler (const ACE_Handle_Set &handles)
	Suspend all handles in handle set temporarily.
virtual int	suspend_handlers (void)
	Suspend all handles temporarily.
virtual int	resume_handler (ACE_Event_Handler *event_handler)
virtual int	resume_handler (ACE_HANDLE handle)
	Resume handle.
virtual int	resume_handler (const ACE_Handle_Set &handles)
	Resume all handles in handle set.
virtual int	resume_handlers (void)
	Resume all <handles>.
virtual int	resumable_handler (void)
virtual bool	uses_event_associations (void)
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)
virtual int	reset_timer_interval (long timer_id, const ACE_Time_Value &interval)
virtual int	cancel_timer (ACE_Event_Handler *event_handler, int dont_call_handle_close=1)
virtual int	cancel_timer (long timer_id, const void **arg=0, int dont_call_handle_close=1)
virtual int	schedule_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_added)
virtual int	schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added)
virtual int	cancel_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_deleted)
virtual int	cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_deleted)
virtual int	notify (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *=0)
virtual void	max_notify_iterations (int)
virtual int	max_notify_iterations (void)
virtual int	purge_pending_notifications (ACE_Event_Handler *=0, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK)
ACE_Event_Handler *	find_handler (ACE_HANDLE handle)
virtual int	handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler=0)
virtual int	handler (int signum, ACE_Event_Handler **=0)
virtual bool	initialized (void)
virtual size_t	size (void) const
virtual ACE_Lock &	lock (void)
	Returns a reference to the WFMO_Reactor's internal lock.
virtual void	wakeup_all_threads (void)
virtual int	owner (ACE_thread_t new_owner, ACE_thread_t *old_owner=0)
virtual int	owner (ACE_thread_t *owner)
	Return the ID of the "owner" thread.
virtual bool	restart (void)
	Get the existing restart value.
virtual bool	restart (bool r)
	Set a new value for restart and return the original value.
virtual void	requeue_position (int)
	Not implemented.
virtual int	requeue_position (void)
	Not implemented.
virtual int	mask_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks, int operation)
virtual int	mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask masks, int ops)
virtual int	ready_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops)
	Not implemented.
virtual int	ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask, int ops)
	Not implemented.
virtual void	dump (void) const
	Dump the state of an object.
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Protected Member Functions
virtual int	register_handler_i (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
	Registration workhorse.
virtual int	event_handling (ACE_Time_Value *max_wait_time=0, int alertable=0)
	Event handling workhorse.
virtual int	mask_ops_i (ACE_HANDLE io_handle, ACE_Reactor_Mask masks, int operation)
	Bit masking workhorse.
virtual ACE_thread_t	owner_i (void)
	Return the ID of the "owner" thread. Does not do any locking.
virtual int	ok_to_wait (ACE_Time_Value *max_wait_time, int alertable)
virtual DWORD	wait_for_multiple_events (int timeout, int alertable)
	Wait for timer and I/O events to occur.
virtual DWORD	poll_remaining_handles (DWORD slot)
	Check for activity on remaining handles.
virtual int	expire_timers (void)
virtual int	dispatch (DWORD wait_status)
	Dispatches the timers and I/O handlers.
virtual int	safe_dispatch (DWORD wait_status)
virtual int	dispatch_handles (DWORD slot)
virtual int	dispatch_handler (DWORD slot, DWORD max_handlep1)
virtual int	simple_dispatch_handler (DWORD slot, ACE_HANDLE event_handle)
virtual int	complex_dispatch_handler (DWORD slot, ACE_HANDLE event_handle)
virtual int	dispatch_window_messages (void)
	Dispatches window messages. Noop for WFMO_Reactor.
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.
virtual int	update_state (void)
	Update the state of the handler repository.
virtual int	new_owner (void)
	Check to see if we have a new owner.
virtual int	change_owner (void)
	Set owner to new owner.
Protected Attributes
ACE_Sig_Handler *	signal_handler_
	Handle signals without requiring global/static variables.
bool	delete_signal_handler_
ACE_Timer_Queue *	timer_queue_
	Defined as a pointer to allow overriding by derived classes...
bool	delete_timer_queue_
bool	delete_handler_rep_
	Keeps track of whether we should delete the handler repository.
ACE_Reactor_Notify *	notify_handler_
	Used when <notify> is called.
bool	delete_notify_handler_
	Keeps track of whether we should delete the notify handler.
ACE_Process_Mutex	lock_
ACE_Lock_Adapter < ACE_Process_Mutex >	lock_adapter_
	Adapter used to return internal lock to outside world.
ACE_WFMO_Reactor_Handler_Repository	handler_rep_
	Table that maps <ACE_HANDLEs> to <ACE_Event_Handler *>'s.
ACE_Manual_Event	ok_to_wait_
ACE_Manual_Event	wakeup_all_threads_
ACE_Wakeup_All_Threads_Handler	wakeup_all_threads_handler_
	Used when <wakeup_all_threads_> is signaled.
ACE_Auto_Event	waiting_to_change_state_
size_t	active_threads_
	Count of currently active threads.
ACE_thread_t	owner_
ACE_thread_t	new_owner_
	The owner to be of the WFMO_Reactor.
ACE_thread_t	change_state_thread_
ACE_HANDLE	atomic_wait_array_ [2]
bool	open_for_business_
	This flag is used to keep track of whether we are already closed.
sig_atomic_t	deactivated_
Private Member Functions
	ACE_WFMO_Reactor (const ACE_WFMO_Reactor &)
	Deny access since member-wise won't work...
ACE_WFMO_Reactor &	operator= (const ACE_WFMO_Reactor &)
Friends
class	ACE_WFMO_Reactor_Handler_Repository
class	ACE_WFMO_Reactor_Test

---

Detailed Description

An object oriented event demultiplexor and event handler. ACE_WFMO_Reactor is a Windows-only implementation of the ACE_Reactor interface that uses the WaitForMultipleObjects() event demultiplexer.

Like the other ACE Reactors, ACE_WFMO_Reactor can schedule timers. It also reacts to signalable handles, such as events (see the documentation for WaitForMultipleObjects() for a complete list of signalable handle types). Therefore, I/O handles are not directly usable for registering for input, output, and exception notification. The exception to this is ACE_SOCK-based handles, which can be registered for input, output, and exception notification just as with other platforms. See Chapter 4 in C++NPv2 for complete details.

Note that changes to the state of ACE_WFMO_Reactor are not instantaneous. Most changes (registration, removal, suspension, and resumption of handles, and changes in ownership) are made when the ACE_WFMO_Reactor reaches a stable state. Users should be careful, especially when removing handlers. This is because the ACE_WFMO_Reactor will call handle_close() on the handler when it is finally removed and not when remove_handler() is called. If the registered handler's pointer is not valid when ACE_WFMO_Reactor calls ACE_Event_Handler::handle_close(), use the DONT_CALL flag with remove_handler(). Preferably, use dynamically allocated event handlers and call "delete this" inside the handle_close() hook method.

Note that although multiple threads can concurrently run the ACE_WFMO_Reactor event loop, the concept of the reactor "owner" is still important. Only the owner thread can expire timers and wait on the notifications handle. Thus, be careful to properly set the owner thread when spawning threads to run the event loop while you are using timers or notifications.

---

Member Enumeration Documentation

anonymous enum

Enumerator:

DEFAULT_SIZE

Default size of the WFMO_Reactor's handle table. Two slots will be added to the size parameter in the constructor and open methods which will store handles used for internal management purposes.

---

Constructor & Destructor Documentation

ACE_WFMO_Reactor::ACE_WFMO_Reactor	(	ACE_Sig_Handler *	sh = 0,
		ACE_Timer_Queue *	tq = 0,
		ACE_Reactor_Notify *	notify = 0
	)

Initialize ACE_WFMO_Reactor with the default size.

ACE_WFMO_Reactor::ACE_WFMO_Reactor	(	size_t	size,
		int	unused = 0,
		ACE_Sig_Handler *	sh = 0,
		ACE_Timer_Queue *	tq = 0,
		ACE_Reactor_Notify *	notify = 0
	)

Initialize ACE_WFMO_Reactor with the specified size.

Parameters:

size	The maximum number of handles the reactor can register. The value 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.

ACE_WFMO_Reactor::~ACE_WFMO_Reactor

(

void

)

[virtual]

Close down the ACE_WFMO_Reactor and release all of its resources.

ACE_WFMO_Reactor::ACE_WFMO_Reactor

(

const ACE_WFMO_Reactor &

)

[private]

Deny access since member-wise won't work...

---

Member Function Documentation

int ACE_WFMO_Reactor::alertable_handle_events

(

ACE_Time_Value *

max_wait_time = 0

)

[inline, virtual]

Implements ACE_Reactor_Impl.

Reimplemented in ACE_Msg_WFMO_Reactor.

int ACE_WFMO_Reactor::alertable_handle_events

(

ACE_Time_Value &

max_wait_time

)

[inline, virtual]

Implements ACE_Reactor_Impl.

Reimplemented in ACE_Msg_WFMO_Reactor.

int ACE_WFMO_Reactor::calculate_timeout

(

ACE_Time_Value *

time

)

[protected, virtual]

Used to caluculate the next timeout.

int ACE_WFMO_Reactor::cancel_timer	(	ACE_Event_Handler *	event_handler,
		int	dont_call_handle_close = 1
	)		[inline, virtual]

Cancel all Event_Handlers that match the address of event_handler. Returns number of handler's cancelled.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::cancel_timer	(	long	timer_id,
		const void **	arg = 0,
		int	dont_call_handle_close = 1
	)		[inline, virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::cancel_wakeup	(	ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	masks_to_be_deleted
	)		[inline, virtual]

Remove masks_to_be_deleted to the <handle>'s entry in WFMO_Reactor. The Event_Handler associated with event_handler must already have been registered with WFMO_Reactor.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::cancel_wakeup	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	masks_to_be_deleted
	)		[inline, virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::change_owner

(

void

)

[inline, protected, virtual]

Set owner to new owner.

int ACE_WFMO_Reactor::close

(

void

)

[virtual]

Close down the ACE_WFMO_Reactor and release all of its resources.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::complex_dispatch_handler	(	DWORD	slot,
		ACE_HANDLE	event_handle
	)		[protected, virtual]

Dispatches a single handler. Returns 0 on success, -1 if the handler was removed.

int ACE_WFMO_Reactor::current_info	(	ACE_HANDLE	,
		size_t &
	)		[virtual]

Returns -1 (not used in this implementation);.

Implements ACE_Reactor_Impl.

void ACE_WFMO_Reactor::deactivate

(

int

do_stop

)

[inline, virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::deactivated

(

void

)

[inline, virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::dispatch

(

DWORD

wait_status

)

[protected, virtual]

Dispatches the timers and I/O handlers.

int ACE_WFMO_Reactor::dispatch_handler	(	DWORD	slot,
		DWORD	max_handlep1
	)		[protected, virtual]

Dispatches a single handler. Returns 0 on success, -1 if the handler was removed.

int ACE_WFMO_Reactor::dispatch_handles

(

DWORD

slot

)

[protected, virtual]

Dispatches any active handles from handles_[slot] to handles_[active_handles_] using <WaitForMultipleObjects> to poll through our handle set looking for active handles.

int ACE_WFMO_Reactor::dispatch_window_messages

(

void

)

[inline, protected, virtual]

Dispatches window messages. Noop for WFMO_Reactor.

Reimplemented in ACE_Msg_WFMO_Reactor.

void ACE_WFMO_Reactor::dump

(

void

)

const [virtual]

Dump the state of an object.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::event_handling	(	ACE_Time_Value *	max_wait_time = 0,
		int	alertable = 0
	)		[protected, virtual]

Event handling workhorse.

int ACE_WFMO_Reactor::expire_timers

(

void

)

[protected, virtual]

Expire timers. Only the owner thread does useful stuff in this function.

ACE_Event_Handler * ACE_WFMO_Reactor::find_handler

(

ACE_HANDLE

handle

)

[inline, virtual]

Return the Event_Handler associated with <handle>. Return 0 if <handle> is not registered.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::handle_events

(

ACE_Time_Value *

max_wait_time = 0

)

[inline, virtual]

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

Implements ACE_Reactor_Impl.

Reimplemented in ACE_Msg_WFMO_Reactor.

int ACE_WFMO_Reactor::handle_events

(

ACE_Time_Value &

max_wait_time

)

[inline, virtual]

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.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_Msg_WFMO_Reactor.

int ACE_WFMO_Reactor::handler	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask,
		ACE_Event_Handler **	event_handler = 0
	)		[inline, virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::handler	(	int	signum,
		ACE_Event_Handler **	eh = 0
	)		[inline, virtual]

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.

Implements ACE_Reactor_Impl.

bool ACE_WFMO_Reactor::initialized

(

void

)

[inline, virtual]

Returns true if WFMO_Reactor has been successfully initialized, else false.

Implements ACE_Reactor_Impl.

ACE_Lock & ACE_WFMO_Reactor::lock

(

void

)

[inline, virtual]

Returns a reference to the WFMO_Reactor's internal lock.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::mask_ops	(	ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	masks,
		int	operation
	)		[inline, virtual]

Modify masks of the event_handler's entry in WFMO_Reactor depending upon <operation>. event_handler must already have been registered with WFMO_Reactor.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::mask_ops	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	masks,
		int	ops
	)		[inline, virtual]

Modify masks of the <handle>'s entry in WFMO_Reactor depending upon <operation>. <handle> must already have been registered with WFMO_Reactor.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::mask_ops_i	(	ACE_HANDLE	io_handle,
		ACE_Reactor_Mask	masks,
		int	operation
	)		[protected, virtual]

Bit masking workhorse.

void ACE_WFMO_Reactor::max_notify_iterations

(

int

iterations

)

[virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::max_notify_iterations

(

void

)

[virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::new_owner

(

void

)

[inline, protected, virtual]

Check to see if we have a new owner.

int ACE_WFMO_Reactor::notify	(	ACE_Event_Handler *	event_handler = 0,
		ACE_Reactor_Mask	mask = ACE_Event_Handler::EXCEPT_MASK,
		ACE_Time_Value *	timeout = 0
	)		[inline, virtual]

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

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::ok_to_wait	(	ACE_Time_Value *	max_wait_time,
		int	alertable
	)		[protected, virtual]

Wait up to max_wait_time until it's ok to enter WaitForMultipleObjects. Returns 1 (and holding lock_) if ok to wait; -1 (and not holding lock_) if not.

int ACE_WFMO_Reactor::open	(	size_t	size = ACE_WFMO_Reactor::DEFAULT_SIZE,
		bool	restart = false,
		ACE_Sig_Handler *	sh = 0,
		ACE_Timer_Queue *	tq = 0,
		int	disable_notify_pipe = 0,
		ACE_Reactor_Notify *	notify = 0
	)		[virtual]

Initialize ACE_WFMO_Reactor with the specified size.

Parameters:

size	The maximum number of handles the reactor can register. The value 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.

Implements ACE_Reactor_Impl.

ACE_WFMO_Reactor& ACE_WFMO_Reactor::operator=

(

const ACE_WFMO_Reactor &

)

[private]

int ACE_WFMO_Reactor::owner	(	ACE_thread_t	new_owner,
		ACE_thread_t *	old_owner = 0
	)		[inline, virtual]

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

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::owner

(

ACE_thread_t *

owner

)

[inline, virtual]

Return the ID of the "owner" thread.

Implements ACE_Reactor_Impl.

ACE_thread_t ACE_WFMO_Reactor::owner_i

(

void

)

[inline, protected, virtual]

Return the ID of the "owner" thread. Does not do any locking.

DWORD ACE_WFMO_Reactor::poll_remaining_handles

(

DWORD

slot

)

[protected, virtual]

Check for activity on remaining handles.

Reimplemented in ACE_Msg_WFMO_Reactor.

int ACE_WFMO_Reactor::purge_pending_notifications	(	ACE_Event_Handler *	eh = 0,
		ACE_Reactor_Mask	mask = ACE_Event_Handler::ALL_EVENTS_MASK
	)		[virtual]

Purge any notifications pending in this reactor for the specified ACE_Event_Handler object. Returns the number of notifications purged. Returns -1 on error.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::ready_ops	(	ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	mask,
		int	ops
	)		[inline, virtual]

Not implemented.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::ready_ops	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	,
		int	ops
	)		[inline, virtual]

Not implemented.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::register_handler	(	ACE_Event_Handler *	event_handler,
		ACE_HANDLE	event_handle = ACE_INVALID_HANDLE
	)		[inline, virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::register_handler	(	ACE_HANDLE	event_handle,
		ACE_HANDLE	io_handle,
		ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

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

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::register_handler	(	ACE_HANDLE	io_handle,
		ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

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>

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::register_handler	(	ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

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>

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::register_handler	(	const ACE_Handle_Set &	handles,
		ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

Register event_handler with all the handles in the <Handle_Set>.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::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
	)		[inline, virtual]

Register new_sh to handle the signal signum using the new_disp. Returns the old_sh that was previously registered (if any), along with the old_disp of the signal handler.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::register_handler	(	const ACE_Sig_Set &	sigset,
		ACE_Event_Handler *	new_sh,
		ACE_Sig_Action *	new_disp = 0
	)		[inline, virtual]

Registers new_sh to handle a set of signals sigset using the new_disp.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::register_handler_i	(	ACE_HANDLE	event_handle,
		ACE_HANDLE	io_handle,
		ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	mask
	)		[protected, virtual]

Registration workhorse.

int ACE_WFMO_Reactor::remove_handler	(	ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

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>

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::remove_handler	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

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>

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::remove_handler	(	const ACE_Handle_Set &	handle_set,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::remove_handler	(	int	signum,
		ACE_Sig_Action *	new_disp,
		ACE_Sig_Action *	old_disp = 0,
		int	sigkey = -1
	)		[inline, virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::remove_handler

(

const ACE_Sig_Set &

sigset

)

[inline, virtual]

Calls remove_handler() for every signal in sigset.

Implements ACE_Reactor_Impl.

void ACE_WFMO_Reactor::requeue_position

(

int

)

[inline, virtual]

Not implemented.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::requeue_position

(

void

)

[inline, virtual]

Not implemented.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::reset_timer_interval	(	long	timer_id,
		const ACE_Time_Value &	interval
	)		[inline, virtual]

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.

Implements ACE_Reactor_Impl.

bool ACE_WFMO_Reactor::restart

(

void

)

[inline, virtual]

Get the existing restart value.

Implements ACE_Reactor_Impl.

bool ACE_WFMO_Reactor::restart

(

bool

r

)

[inline, virtual]

Set a new value for restart and return the original value.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::resumable_handler

(

void

)

[virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::resume_handler

(

ACE_Event_Handler *

event_handler

)

[inline, virtual]

Resume event_handler. Use <ACE_Event_Handler::get_handle> to get the handle.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::resume_handler

(

ACE_HANDLE

handle

)

[inline, virtual]

Resume handle.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::resume_handler

(

const ACE_Handle_Set &

handles

)

[inline, virtual]

Resume all handles in handle set.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::resume_handlers

(

void

)

[inline, virtual]

Resume all <handles>.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::safe_dispatch

(

DWORD

wait_status

)

[inline, protected, virtual]

Protect against structured exceptions caused by user code when dispatching handles

long ACE_WFMO_Reactor::schedule_timer	(	ACE_Event_Handler *	event_handler,
		const void *	arg,
		const ACE_Time_Value &	delay,
		const ACE_Time_Value &	interval = ACE_Time_Value::zero
	)		[inline, virtual]

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.

See also:

cancel_timer()

reset_timer_interval()

Parameters:

event_handler	event handler to schedule on reactor
arg	argument passed to the handle_timeout() method of event_handler
delay	time interval after which the timer will expire
interval	time interval after which the timer will be automatically rescheduled

Returns:

-1 on failure, a timer_id value on success

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::schedule_wakeup	(	ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	masks_to_be_added
	)		[inline, virtual]

Add masks_to_be_added to the event_handler's entry in WFMO_Reactor. event_handler must already have been registered with WFMO_Reactor.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::schedule_wakeup	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	masks_to_be_added
	)		[inline, virtual]

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.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::set_sig_handler

(

ACE_Sig_Handler *

signal_handler

)

[virtual]

Use a user specified signal handler instead.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::simple_dispatch_handler	(	DWORD	slot,
		ACE_HANDLE	event_handle
	)		[protected, virtual]

Dispatches a single handler. Returns 0 on success, -1 if the handler was removed.

size_t ACE_WFMO_Reactor::size

(

void

)

const [inline, virtual]

Returns the current size of the WFMO_Reactor's internal descriptor table.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::suspend_handler

(

ACE_Event_Handler *

event_handler

)

[inline, virtual]

Suspend event_handler temporarily. Use ACE_Event_Handler::get_handle() to get the handle.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::suspend_handler

(

ACE_HANDLE

handle

)

[inline, virtual]

Suspend handle temporarily.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::suspend_handler

(

const ACE_Handle_Set &

handles

)

[inline, virtual]

Suspend all handles in handle set temporarily.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::suspend_handlers

(

void

)

[inline, virtual]

Suspend all handles temporarily.

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::timer_queue

(

ACE_Timer_Queue *

tq

)

[virtual]

Set a user-specified timer queue.

Implements ACE_Reactor_Impl.

ACE_Timer_Queue * ACE_WFMO_Reactor::timer_queue

(

void

)

const [virtual]

Return the current ACE_Timer_Queue.

Implements ACE_Reactor_Impl.

ACE_Reactor_Mask ACE_WFMO_Reactor::upcall	(	ACE_Event_Handler *	event_handler,
		ACE_HANDLE	io_handle,
		WSANETWORKEVENTS &	events
	)		[protected, virtual]

int ACE_WFMO_Reactor::update_state

(

void

)

[protected, virtual]

Update the state of the handler repository.

bool ACE_WFMO_Reactor::uses_event_associations

(

void

)

[inline, virtual]

Return true if we any event associations were made by the reactor for the handles that it waits on, false otherwise. Since the WFMO_Reactor does use event associations, this function always return true.

Implements ACE_Reactor_Impl.

DWORD ACE_WFMO_Reactor::wait_for_multiple_events	(	int	timeout,
		int	alertable
	)		[protected, virtual]

Wait for timer and I/O events to occur.

Reimplemented in ACE_Msg_WFMO_Reactor.

void ACE_WFMO_Reactor::wakeup_all_threads

(

void

)

[inline, virtual]

Wake up all threads in WaitForMultipleObjects so that they can reconsult the handle set

Implements ACE_Reactor_Impl.

int ACE_WFMO_Reactor::work_pending

(

const ACE_Time_Value &

max_wait_time = ACE_Time_Value::zero

)

[virtual]

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.

Implements ACE_Reactor_Impl.

---

Friends And Related Function Documentation

friend class ACE_WFMO_Reactor_Handler_Repository [friend]

friend class ACE_WFMO_Reactor_Test [friend]

---

Member Data Documentation

ACE_WFMO_Reactor::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

Reimplemented from ACE_Reactor_Impl.

size_t ACE_WFMO_Reactor::active_threads_ [protected]

Count of currently active threads.

ACE_HANDLE ACE_WFMO_Reactor::atomic_wait_array_[2] [protected]

This is an array of ACE_HANDLEs which keep track of the <lock_> and <ok_to_wait_> handles

ACE_thread_t ACE_WFMO_Reactor::change_state_thread_ [protected]

This is the thread which is responsible for the changing the state of the <WFMO_Reactor> handle set

sig_atomic_t ACE_WFMO_Reactor::deactivated_ [protected]

This flag is used to keep track of whether we are actively handling events or not.

bool ACE_WFMO_Reactor::delete_handler_rep_ [protected]

Keeps track of whether we should delete the handler repository.

bool ACE_WFMO_Reactor::delete_notify_handler_ [protected]

Keeps track of whether we should delete the notify handler.

bool ACE_WFMO_Reactor::delete_signal_handler_ [protected]

Keeps track of whether we should delete the signal handler (if we didn't create it, then we don't delete it).

bool ACE_WFMO_Reactor::delete_timer_queue_ [protected]

Keeps track of whether we should delete the timer queue (if we didn't create it, then we don't delete it).

ACE_WFMO_Reactor_Handler_Repository ACE_WFMO_Reactor::handler_rep_ [protected]

Table that maps <ACE_HANDLEs> to <ACE_Event_Handler *>'s.

ACE_Process_Mutex ACE_WFMO_Reactor::lock_ [protected]

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.

ACE_Lock_Adapter<ACE_Process_Mutex> ACE_WFMO_Reactor::lock_adapter_ [protected]

Adapter used to return internal lock to outside world.

ACE_thread_t ACE_WFMO_Reactor::new_owner_ [protected]

The owner to be of the WFMO_Reactor.

ACE_Reactor_Notify* ACE_WFMO_Reactor::notify_handler_ [protected]

Used when <notify> is called.

ACE_Manual_Event ACE_WFMO_Reactor::ok_to_wait_ [protected]

A manual event used to block threads from proceeding into WaitForMultipleObjects

bool ACE_WFMO_Reactor::open_for_business_ [protected]

This flag is used to keep track of whether we are already closed.

ACE_thread_t ACE_WFMO_Reactor::owner_ [protected]

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.

ACE_Sig_Handler* ACE_WFMO_Reactor::signal_handler_ [protected]

Handle signals without requiring global/static variables.

ACE_Timer_Queue* ACE_WFMO_Reactor::timer_queue_ [protected]

Defined as a pointer to allow overriding by derived classes...

ACE_Auto_Event ACE_WFMO_Reactor::waiting_to_change_state_ [protected]

The changing thread waits on this event, till all threads are not active anymore

ACE_Manual_Event ACE_WFMO_Reactor::wakeup_all_threads_ [protected]

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

ACE_Wakeup_All_Threads_Handler ACE_WFMO_Reactor::wakeup_all_threads_handler_ [protected]

Used when <wakeup_all_threads_> is signaled.

---

The documentation for this class was generated from the following files:

• WFMO_Reactor.h
• WFMO_Reactor.cpp
• WFMO_Reactor.inl