ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > Class Template Reference

An object oriented event demultiplexor and event handler dispatcher. More...

#include <Select_Reactor_T.h>

Inheritance diagram for ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >:

Collaboration diagram for ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >:

List of all members.

Public Member Functions
	ACE_Select_Reactor_T (ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=ACE_DISABLE_NOTIFY_PIPE_DEFAULT, ACE_Reactor_Notify *notify=0, bool mask_signals=true, int s_queue=ACE_SELECT_TOKEN::FIFO)
	ACE_Select_Reactor_T (size_t size, bool restart=false, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=ACE_DISABLE_NOTIFY_PIPE_DEFAULT, ACE_Reactor_Notify *notify=0, bool mask_signals=true, int s_queue=ACE_SELECT_TOKEN::FIFO)
virtual int	open (size_t max_number_of_handles=DEFAULT_SIZE, bool restart=false, ACE_Sig_Handler *=0, ACE_Timer_Queue *=0, int disable_notify_pipe=ACE_DISABLE_NOTIFY_PIPE_DEFAULT, ACE_Reactor_Notify *=0)
virtual int	current_info (ACE_HANDLE, size_t &size)
	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 select_reactor and release all of its resources.
virtual	~ACE_Select_Reactor_T (void)
	Close down the select_reactor and release all of its resources.
virtual int	work_pending (const ACE_Time_Value &max_wait_time=ACE_Time_Value::zero)
virtual int	deactivated (void)
virtual void	deactivate (int do_stop)
virtual int	register_handler (ACE_Event_Handler *eh, ACE_Reactor_Mask mask)
virtual int	register_handler (ACE_HANDLE handle, ACE_Event_Handler *eh, ACE_Reactor_Mask mask)
virtual int	register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle=ACE_INVALID_HANDLE)
	Not implemented.
virtual int	register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask)
	Not implemented.
virtual int	register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *eh, ACE_Reactor_Mask mask)
	Register eh with all the handles in the <Handle_Set>.
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 *eh, ACE_Reactor_Mask mask)
virtual int	remove_handler (ACE_HANDLE handle, ACE_Reactor_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 *eh)
	Temporarily suspend the <Event_Handler> associated with eh.
virtual int	suspend_handler (ACE_HANDLE handle)
	Temporarily suspend the Event_Handler associated with handle.
virtual int	suspend_handler (const ACE_Handle_Set &handles)
	Suspend all handles in handle set temporarily.
virtual int	suspend_handlers (void)
	Suspend all the <Event_Handlers> in the Select_Reactor.
virtual int	resume_handler (ACE_Event_Handler *eh)
virtual int	resume_handler (ACE_HANDLE handle)
virtual int	resume_handler (const ACE_Handle_Set &handles)
	Resume all handles in handle set.
virtual int	resume_handlers (void)
	Resume all the <Event_Handlers> in the Select_Reactor.
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 *eh, ACE_Reactor_Mask mask)
	ADD the dispatch MASK "bit" bound with the eh and the mask.
virtual int	schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask mask)
	ADD the dispatch MASK "bit" bound with the handle and the mask.
virtual int	cancel_wakeup (ACE_Event_Handler *eh, ACE_Reactor_Mask mask)
	CLR the dispatch MASK "bit" bound with the eh and the mask.
virtual int	cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask mask)
	CLR the dispatch MASK "bit" bound with the handle and the mask.
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 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)
virtual int	requeue_position (void)
virtual int	mask_ops (ACE_Event_Handler *eh, ACE_Reactor_Mask mask, int ops)
virtual int	mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops)
virtual int	ready_ops (ACE_Event_Handler *eh, ACE_Reactor_Mask mask, int ops)
	GET/SET/ADD/CLR the ready "bit" bound with the eh and mask.
virtual int	ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask, int ops)
	GET/SET/ADD/CLR the ready "bit" bound with the handle and mask.
virtual void	wakeup_all_threads (void)
	Wake up all threads in waiting in the event loop.
virtual int	owner (ACE_thread_t n_id, ACE_thread_t *o_id=0)
	Set the new owner of the thread and return the old owner.
virtual int	owner (ACE_thread_t *)
	Return the current owner of the thread.
virtual ACE_Event_Handler *	find_handler (ACE_HANDLE handle)
virtual int	handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **eh=0)
virtual int	handler (int signum, ACE_Event_Handler **=0)
virtual bool	initialized (void)
	Returns true if we've been successfully initialized, else false.
virtual size_t	size (void) const
virtual ACE_Lock &	lock (void)
virtual void	dump (void) const
	Dump the state of an object.
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)
Public Attributes
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.
Protected Member Functions
virtual int	register_handler_i (ACE_HANDLE handle, ACE_Event_Handler *eh, ACE_Reactor_Mask mask)
virtual int	register_handler_i (const ACE_Handle_Set &handles, ACE_Event_Handler *handler, ACE_Reactor_Mask mask)
	Register a set of handles.
virtual int	remove_handler_i (ACE_HANDLE handle, ACE_Reactor_Mask)
virtual int	remove_handler_i (const ACE_Handle_Set &handles, ACE_Reactor_Mask)
	Remove a set of handles.
virtual int	suspend_i (ACE_HANDLE handle)
	Suspend the <Event_Handler> associated with handle.
virtual int	is_suspended_i (ACE_HANDLE handle)
virtual int	resume_i (ACE_HANDLE handle)
	Resume the <Event_Handler> associated with handle.
virtual ACE_Event_Handler *	find_handler_i (ACE_HANDLE handle)
	Implement the public handler method.
virtual int	handler_i (ACE_HANDLE handle, ACE_Reactor_Mask, ACE_Event_Handler **=0)
	Implement the public handler method.
virtual int	handler_i (int signum, ACE_Event_Handler **=0)
	Implement the public handler method.
virtual int	any_ready (ACE_Select_Reactor_Handle_Set &handle_set)
virtual int	any_ready_i (ACE_Select_Reactor_Handle_Set &handle_set)
virtual int	handle_error (void)
	Take corrective action when errors occur.
virtual int	check_handles (void)
	Make sure the handles are all valid.
virtual int	wait_for_multiple_events (ACE_Select_Reactor_Handle_Set &, ACE_Time_Value *)
	Wait for events to occur.
virtual int	dispatch (int nfound, ACE_Select_Reactor_Handle_Set &)
virtual int	dispatch_timer_handlers (int &number_dispatched)
virtual int	dispatch_notification_handlers (ACE_Select_Reactor_Handle_Set &dispatch_set, int &number_of_active_handles, int &number_of_handlers_dispatched)
virtual int	dispatch_io_handlers (ACE_Select_Reactor_Handle_Set &dispatch_set, int &number_of_active_handles, int &number_of_handlers_dispatched)
virtual int	dispatch_io_set (int number_of_active_handles, int &number_of_handlers_dispatched, int mask, ACE_Handle_Set &dispatch_mask, ACE_Handle_Set &ready_mask, ACE_EH_PTMF callback)
virtual void	notify_handle (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Handle_Set &, ACE_Event_Handler *eh, ACE_EH_PTMF callback)
virtual void	renew (void)
int	release_token (void)
	Release the token lock when a Win32 structured exception occurs.
int	handle_events_i (ACE_Time_Value *max_wait_time=0)
	Stops the VC++ compiler from bitching about exceptions and destructors.
Protected Attributes
ACE_SELECT_REACTOR_TOKEN	token_
	Synchronization token for the MT_SAFE ACE_Select_Reactor.
ACE_Lock_Adapter < ACE_SELECT_REACTOR_TOKEN >	lock_adapter_
	Adapter used to return internal lock to outside world.
sig_atomic_t	deactivated_
Private Member Functions
	ACE_Select_Reactor_T (const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &)
	Deny access since member-wise won't work...
ACE_Select_Reactor_T < ACE_SELECT_REACTOR_TOKEN > &	operator= (const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &)

---

Detailed Description

template<class ACE_SELECT_REACTOR_TOKEN>
class ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >

An object oriented event demultiplexor and event handler dispatcher.

The ACE_Select_Reactor is an object-oriented event demultiplexor and event handler dispatcher. The sources of events that the ACE_Select_Reactor waits for and dispatches includes I/O events, signals, and timer events. All public methods acquire the main ACE_Reactor_Token lock and call down to private or protected methods, which assume that the lock is held and so therefore don't (re)acquire the lock.

---

Constructor & Destructor Documentation

template<class ACE_SELECT_REACTOR_TOKEN >

ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_Select_Reactor_T	(	ACE_Sig_Handler *	sh = 0,
		ACE_Timer_Queue *	tq = 0,
		int	disable_notify_pipe = ACE_DISABLE_NOTIFY_PIPE_DEFAULT,
		ACE_Reactor_Notify *	notify = 0,
		bool	mask_signals = true,
		int	s_queue = ACE_SELECT_TOKEN::FIFO
	)

If disable_notify_pipe is non-0 then the reactor will not create a notification pipe, which will save two I/O handles but will elide the notify() feature. If mask_signals is true the reactor is "signal-safe" when dispatching handlers to signal events, whereas if mask_signals is false the reactor will be more efficient, but not signal-safe (which may be perfectly fine if your application doesn't use the reactor to handle signals).

template<class ACE_SELECT_REACTOR_TOKEN >

ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_Select_Reactor_T	(	size_t	size,
		bool	restart = false,
		ACE_Sig_Handler *	sh = 0,
		ACE_Timer_Queue *	tq = 0,
		int	disable_notify_pipe = ACE_DISABLE_NOTIFY_PIPE_DEFAULT,
		ACE_Reactor_Notify *	notify = 0,
		bool	mask_signals = true,
		int	s_queue = ACE_SELECT_TOKEN::FIFO
	)

Initialize ACE_Select_Reactor with size

• size. If
• disable_notify_pipe is non-0 then the reactor will not create a notification pipe, which will save two I/O handles but will elide the notification feature. If
• mask_signals is true the reactor is "signal-safe" when dispatching handlers to signal events, whereas if
• mask_signals is false the reactor will be more efficient, but not signal-safe (which may be perfectly fine if your application doesn't use the reactor to handle signals).

  Note:

  On Unix platforms, the size parameter should be as large as the maximum number of file descriptors allowed for a given process. This is necessary since a file descriptor is used to directly index the array of event handlers maintained by the Reactor's handler repository. Direct indexing is used for efficiency reasons.

template<class ACE_SELECT_REACTOR_TOKEN >

ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::~ACE_Select_Reactor_T

(

void

)

[virtual]

Close down the select_reactor and release all of its resources.

template<class ACE_SELECT_REACTOR_TOKEN>

ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_Select_Reactor_T

(

const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &

)

[private]

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

---

Member Function Documentation

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::alertable_handle_events

(

ACE_Time_Value *

max_wait_time = 0

)

[inline, virtual]

This event loop driver that blocks for 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.

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 something goes wrong.

Current alertable_handle_events() is identical to handle_events().

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::alertable_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.

Current <alertable_handle_events> is identical to <handle_events>.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::any_ready

(

ACE_Select_Reactor_Handle_Set &

handle_set

)

[protected, virtual]

Check if there are any HANDLEs enabled in the <ready_set_>, and if so, update the handle_set and return the number ready. If there aren't any HANDLEs enabled return 0.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::any_ready_i

(

ACE_Select_Reactor_Handle_Set &

handle_set

)

[protected, virtual]

Implement the <any_ready> method, assuming that the Sig_Guard is being held

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_timer	(	ACE_Event_Handler *	event_handler,
		int	dont_call_handle_close = 1
	)		[virtual]

Cancel all <event_handlers> that match the address of event_handler. If dont_call_handle_close is 0 then the <handle_close> method of event_handler will be invoked. Returns number of handler's cancelled.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_timer	(	long	timer_id,
		const void **	arg = 0,
		int	dont_call_handle_close = 1
	)		[virtual]

Cancel the single ACE_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. If dont_call_handle_close is 0 then the <handle_close> method of <event_handler> will be invoked. Returns 1 if cancellation succeeded and 0 if the timer_id wasn't found.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_wakeup	(	ACE_Event_Handler *	eh,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

CLR the dispatch MASK "bit" bound with the eh and the mask.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::cancel_wakeup	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

CLR the dispatch MASK "bit" bound with the handle and the mask.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::check_handles

(

void

)

[protected, virtual]

Make sure the handles are all valid.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::close

(

void

)

[virtual]

Close down the select_reactor and release all of its resources.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::current_info	(	ACE_HANDLE	,
		size_t &	size
	)		[virtual]

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

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch	(	int	nfound,
		ACE_Select_Reactor_Handle_Set &	dispatch_set
	)		[protected, virtual]

Template Method that dispatches ACE_Event_Handlers for time events, I/O events, and signal events. Returns the total number of ACE_Event_Handlers that were dispatched or -1 if something goes wrong.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_io_handlers	(	ACE_Select_Reactor_Handle_Set &	dispatch_set,
		int &	number_of_active_handles,
		int &	number_of_handlers_dispatched
	)		[protected, virtual]

Dispatch all the input/output/except handlers that are enabled in the dispatch_set. Updates number_of_active_handles and number_of_handlers_dispatched according to the behavior of the number Returns -1 if the state of the <wait_set_> has changed, else 0.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_io_set	(	int	number_of_active_handles,
		int &	number_of_handlers_dispatched,
		int	mask,
		ACE_Handle_Set &	dispatch_mask,
		ACE_Handle_Set &	ready_mask,
		ACE_EH_PTMF	callback
	)		[protected, virtual]

Factors the dispatching of an io handle set (each WRITE, EXCEPT or READ set of handles). It updates the number_of_handlers_dispatched and invokes this->notify_handle for all the handles in <dispatch_set> using the mask, <ready_set> and callback parameters. Must return -1 if this->state_changed otherwise it must return 0.

Reimplemented in ACE_Priority_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_notification_handlers	(	ACE_Select_Reactor_Handle_Set &	dispatch_set,
		int &	number_of_active_handles,
		int &	number_of_handlers_dispatched
	)		[protected, virtual]

Dispatch any notification handlers. Returns -1 if the state of the <wait_set_> has changed, else returns number of handlers notified.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dispatch_timer_handlers

(

int &

number_dispatched

)

[protected, virtual]

Dispatch all timer handlers that have expired. Returns -1 if the state of the <wait_set_> has changed, else 0. <number_dispatched> is set to the number of timer handlers dispatched.

template<class ACE_SELECT_REACTOR_TOKEN >

void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::dump

(

void

)

const [virtual]

Dump the state of an object.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_Priority_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN >

ACE_Event_Handler * ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::find_handler

(

ACE_HANDLE

handle

)

[virtual]

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

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

ACE_Event_Handler * ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::find_handler_i

(

ACE_HANDLE

handle

)

[protected, virtual]

Implement the public handler method.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_error

(

void

)

[protected, virtual]

Take corrective action when errors occur.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_events

(

ACE_Time_Value *

max_wait_time = 0

)

[virtual]

This event loop driver that blocks for 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.

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 something goes wrong.

Current alertable_handle_events() is identical to handle_events().

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

Current <alertable_handle_events> is identical to <handle_events>.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handle_events_i

(

ACE_Time_Value *

max_wait_time = 0

)

[protected]

Stops the VC++ compiler from bitching about exceptions and destructors.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask,
		ACE_Event_Handler **	eh = 0
	)		[virtual]

Check to see if handle is associated with a valid Event_Handler bound to mask. Return the eh associated with this handler if eh != 0.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler	(	int	signum,
		ACE_Event_Handler **	handler = 0
	)		[inline, virtual]

Check to see if signum is associated with a valid Event_Handler bound to a signal. Return the eh associated with this handler if eh != 0.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler_i	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask,
		ACE_Event_Handler **	eh = 0
	)		[protected, virtual]

Implement the public handler method.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::handler_i	(	int	signum,
		ACE_Event_Handler **	eh = 0
	)		[protected, virtual]

Implement the public handler method.

template<class ACE_SELECT_REACTOR_TOKEN >

bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::initialized

(

void

)

[virtual]

Returns true if we've been successfully initialized, else false.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::is_suspended_i

(

ACE_HANDLE

handle

)

[protected, virtual]

Check to see if the <Event_Handler> associated with handle is suspended. Returns 0 if not, 1 if so.

Implements ACE_Select_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

ACE_Lock & ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::lock

(

void

)

[inline, virtual]

Returns a reference to the ACE_Reactor_Token that is used to serialize the internal processing logic. This can be useful for situations where you need to avoid deadlock efficiently when ACE_Event_Handlers are used in multiple threads.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::mask_ops	(	ACE_Event_Handler *	eh,
		ACE_Reactor_Mask	mask,
		int	ops
	)		[inline, virtual]

GET/SET/ADD/CLR the dispatch mask "bit" bound with the eh and mask.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::mask_ops	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask,
		int	ops
	)		[virtual]

GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::max_notify_iterations

(

int

iterations

)

[virtual]

Set the maximum number of times that the <ACE_Select_Reactor_Notify::handle_input> method will iterate and dispatch the ACE_Event_Handlers that are passed in via the notify pipe before breaking out of its <recv> loop. By default, this is set to -1, which means "iterate until the pipe 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.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::max_notify_iterations

(

void

)

[virtual]

Get the maximum number of times that the <ACE_Select_Reactor_Notify::handle_input> method will iterate and dispatch the ACE_Event_Handlers that are passed in via the notify pipe before breaking out of its <recv> loop.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify	(	ACE_Event_Handler *	eh = 0,
		ACE_Reactor_Mask	mask = ACE_Event_Handler::EXCEPT_MASK,
		ACE_Time_Value *	timeout = 0
	)		[virtual]

Called by a thread when it wants to unblock the Select_Reactor. This wakeups the <ACE_Select_Reactor> if currently blocked in <select>/<poll>. Pass over both the Event_Handler *and* the mask to allow the caller to dictate which <Event_Handler> method the <Select_Reactor> will invoke. The ACE_Time_Value indicates how long to blocking trying to notify the <Select_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.

template<class ACE_SELECT_REACTOR_TOKEN >

void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::notify_handle	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask,
		ACE_Handle_Set &	ready_mask,
		ACE_Event_Handler *	eh,
		ACE_EH_PTMF	callback
	)		[protected, virtual]

Notify the appropriate callback in the context of the eh associated with handle that a particular event has occurred.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::open	(	size_t	max_number_of_handles = DEFAULT_SIZE,
		bool	restart = false,
		ACE_Sig_Handler *	sh = 0,
		ACE_Timer_Queue *	tq = 0,
		int	disable_notify_pipe = ACE_DISABLE_NOTIFY_PIPE_DEFAULT,
		ACE_Reactor_Notify *	notify = 0
	)		[virtual]

Initialize the ACE_Select_Reactor to manage

• max_number_of_handles. If
• restart is non-0 then the ACE_Reactor's handle_events method will be restarted automatically when EINTR occurs. If
• signal_handler or
• timer_queue are non-0 they are used as the signal handler and timer queue, respectively. If
• disable_notify_pipe is non-0 the notification pipe is not created, thereby saving two I/O handles.

Note:

On Unix platforms, the maximum_number_of_handles parameter should be as large as the maximum number of file descriptors allowed for a given process. This is necessary since a file descriptor is used to directly index the array of event handlers maintained by the Reactor's handler repository. Direct indexing is used for efficiency reasons.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN>

ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>& ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::operator=

(

const ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > &

)

[private]

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::owner	(	ACE_thread_t	n_id,
		ACE_thread_t *	o_id = 0
	)		[virtual]

Set the new owner of the thread and return the old owner.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::owner

(

ACE_thread_t *

t_id

)

[virtual]

Return the current owner of the thread.

Implements ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ready_ops	(	ACE_Event_Handler *	eh,
		ACE_Reactor_Mask	mask,
		int	ops
	)		[inline, virtual]

GET/SET/ADD/CLR the ready "bit" bound with the eh and mask.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ready_ops	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask,
		int	ops
	)		[virtual]

GET/SET/ADD/CLR the ready "bit" bound with the handle and mask.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler	(	ACE_Event_Handler *	eh,
		ACE_Reactor_Mask	mask
	)		[virtual]

Register a eh with a particular mask. Note that the <Select_Reactor> will call ACE_Event_Handler::get_handle() to extract the underlying I/O handle.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler	(	ACE_HANDLE	handle,
		ACE_Event_Handler *	eh,
		ACE_Reactor_Mask	mask
	)		[virtual]

Register a eh with a particular mask. Note that since the handle is given the Select_Reactor will *not* call ACE_Event_Handler::get_handle() to extract the underlying I/O handle.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler	(	ACE_Event_Handler *	event_handler,
		ACE_HANDLE	event_handle = ACE_INVALID_HANDLE
	)		[inline, virtual]

Not implemented.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler	(	ACE_HANDLE	event_handle,
		ACE_HANDLE	io_handle,
		ACE_Event_Handler *	event_handler,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

Not implemented.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler	(	const ACE_Handle_Set &	handles,
		ACE_Event_Handler *	eh,
		ACE_Reactor_Mask	mask
	)		[virtual]

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

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler	(	const ACE_Sig_Set &	sigset,
		ACE_Event_Handler *	new_sh,
		ACE_Sig_Action *	new_disp = 0
	)		[virtual]

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

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler_i	(	ACE_HANDLE	handle,
		ACE_Event_Handler *	eh,
		ACE_Reactor_Mask	mask
	)		[protected, virtual]

Do the work of actually binding the handle and eh with the mask.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::register_handler_i	(	const ACE_Handle_Set &	handles,
		ACE_Event_Handler *	handler,
		ACE_Reactor_Mask	mask
	)		[protected, virtual]

Register a set of handles.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::release_token

(

void

)

[protected]

Release the token lock when a Win32 structured exception occurs.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler	(	ACE_Event_Handler *	eh,
		ACE_Reactor_Mask	mask
	)		[virtual]

Removes the mask binding of eh from the Select_Reactor. If there are no more bindings for this eh then it is removed from the Select_Reactor. Note that the Select_Reactor will call <ACE_Event_Handler::get_handle> to extract the underlying I/O handle.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask
	)		[virtual]

Removes the mask bind of Event_Handler whose handle is handle from the Select_Reactor. If there are no more bindings for this eh then it is removed from the Select_Reactor.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler	(	const ACE_Handle_Set &	handle_set,
		ACE_Reactor_Mask	mask
	)		[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 handlers then they are removed from the Select_Reactor.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler

(

const ACE_Sig_Set &

sigset

)

[virtual]

Calls <remove_handler> for every signal in sigset.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler_i	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask
	)		[protected, virtual]

Do the work of actually unbinding the handle and eh with the mask.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler_i	(	const ACE_Handle_Set &	handles,
		ACE_Reactor_Mask	mask
	)		[protected, virtual]

Remove a set of handles.

template<class ACE_SELECT_REACTOR_TOKEN >

void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::renew

(

void

)

[protected, virtual]

Enqueue ourselves into the list of waiting threads at the appropriate point specified by <requeue_position_>.

Implements ACE_Select_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::requeue_position

(

int

rp

)

[virtual]

Set position that the main ACE_Select_Reactor thread is requeued in the list of waiters during a <notify> callback.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::requeue_position

(

void

)

[virtual]

Get position that the main ACE_Select_Reactor thread is requeued in the list of waiters during a <notify> callback.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::reset_timer_interval	(	long	timer_id,
		const ACE_Time_Value &	interval
	)		[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.

template<class ACE_SELECT_REACTOR_TOKEN >

bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::restart

(

void

)

[virtual]

Get the existing restart value.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::restart

(

bool

r

)

[virtual]

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

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler

(

ACE_Event_Handler *

eh

)

[inline, virtual]

Resume a temporarily suspend Event_Handler associated with eh.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler

(

ACE_HANDLE

handle

)

[virtual]

Resume a temporarily suspended Event_Handler associated with handle.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handler

(

const ACE_Handle_Set &

handles

)

[inline, virtual]

Resume all handles in handle set.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_handlers

(

void

)

[virtual]

Resume all the <Event_Handlers> in the Select_Reactor.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::resume_i

(

ACE_HANDLE

handle

)

[protected, virtual]

Resume the <Event_Handler> associated with handle.

template<class ACE_SELECT_REACTOR_TOKEN >

long ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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]

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.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::schedule_wakeup	(	ACE_Event_Handler *	eh,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

ADD the dispatch MASK "bit" bound with the eh and the mask.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::schedule_wakeup	(	ACE_HANDLE	handle,
		ACE_Reactor_Mask	mask
	)		[inline, virtual]

ADD the dispatch MASK "bit" bound with the handle and the mask.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::set_sig_handler

(

ACE_Sig_Handler *

signal_handler

)

[virtual]

Use a user specified signal handler instead.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

size_t ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::size

(

void

)

const [inline, virtual]

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

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler

(

ACE_Event_Handler *

eh

)

[inline, virtual]

Temporarily suspend the <Event_Handler> associated with eh.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler

(

ACE_HANDLE

handle

)

[virtual]

Temporarily suspend the Event_Handler associated with handle.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handler

(

const ACE_Handle_Set &

handles

)

[inline, virtual]

Suspend all handles in handle set temporarily.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_handlers

(

void

)

[virtual]

Suspend all the <Event_Handlers> in the Select_Reactor.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::suspend_i

(

ACE_HANDLE

handle

)

[protected, virtual]

Suspend the <Event_Handler> associated with handle.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::timer_queue

(

ACE_Timer_Queue *

tq

)

[virtual]

Set a user-specified timer queue.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

ACE_Timer_Queue * ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::timer_queue

(

void

)

const [virtual]

Return the current ACE_Timer_Queue.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

bool ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::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 Select_Reactor does not do any event associations, this function always return false.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::wait_for_multiple_events	(	ACE_Select_Reactor_Handle_Set &	dispatch_set,
		ACE_Time_Value *	max_wait_time
	)		[protected, virtual]

Wait for events to occur.

template<class ACE_SELECT_REACTOR_TOKEN >

void ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::wakeup_all_threads

(

void

)

[inline, virtual]

Wake up all threads in waiting in the event loop.

Implements ACE_Reactor_Impl.

template<class ACE_SELECT_REACTOR_TOKEN >

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::work_pending

(

const ACE_Time_Value &

max_wait_time = ACE_Time_Value::zero

)

[virtual]

Returns non-zero if there are I/O events "ready" for dispatching, but does not actually dispatch the event handlers. By default, don't block while checking this, i.e., "poll".

Implements ACE_Reactor_Impl.

---

Member Data Documentation

template<class ACE_SELECT_REACTOR_TOKEN>

ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

Reimplemented from ACE_Reactor_Impl.

Reimplemented in ACE_TP_Reactor, and ACE_Priority_Reactor.

template<class ACE_SELECT_REACTOR_TOKEN>

sig_atomic_t ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::deactivated_ [protected]

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

template<class ACE_SELECT_REACTOR_TOKEN>

ACE_Lock_Adapter<ACE_SELECT_REACTOR_TOKEN> ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::lock_adapter_ [protected]

Adapter used to return internal lock to outside world.

template<class ACE_SELECT_REACTOR_TOKEN>

ACE_SELECT_REACTOR_TOKEN ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::token_ [protected]

Synchronization token for the MT_SAFE ACE_Select_Reactor.

---

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

• Select_Reactor_T.h
• Select_Reactor_T.cpp
• Select_Reactor_T.inl