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

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	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 *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_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.
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.

Definition at line 55 of file Select_Reactor_T.h.

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

Definition at line 476 of file Select_Reactor_T.cpp.

    : ACE_Select_Reactor_Impl (mask_signals)
    , token_ (s_queue)
    , lock_adapter_ (token_)
    , deactivated_ (0)
{
  ACE_TRACE ("ACE_Select_Reactor_T::ACE_Select_Reactor_T");

  this->token_.reactor (*this);
  // First try to open the Reactor with the hard-coded default.
  if (this->open (ACE_Select_Reactor_T<ACE_SELECT_REACTOR_TOKEN>::DEFAULT_SIZE,
                  0,
                  sh,
                  tq,
                  disable_notify_pipe,
                  notify) == -1)
    {
      // The hard-coded default Reactor size failed, so attempt to
      // determine the size at run-time by checking the process file
      // descriptor limit on platforms that support this feature.

      // There is no need to deallocate resources from previous open()
      // call since the open() method deallocates any resources prior
      // to exiting if an error was encountered.

      // Set the default reactor size to be the current limit on the
      // number of file descriptors available to the process.  This
      // size is not necessarily the maximum limit.
      if (this->open (ACE::max_handles (),
                     0,
                     sh,
                     tq,
                     disable_notify_pipe,
                     notify) == -1)
        ACE_ERROR ((LM_ERROR,
                    ACE_TEXT ("%p\n"),
                    ACE_TEXT ("ACE_Select_Reactor_T::open ")
                    ACE_TEXT ("failed inside ")
                    ACE_TEXT ("ACE_Select_Reactor_T::CTOR")));
    }
}

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.

Definition at line 527 of file Select_Reactor_T.cpp.

    : ACE_Select_Reactor_Impl (mask_signals)
    , token_ (s_queue)
    , lock_adapter_ (token_)
    , deactivated_ (0)
{
  ACE_TRACE ("ACE_Select_Reactor_T::ACE_Select_Reactor_T");

  this->token_.reactor (*this);
  if (this->open (size,
                  restart,
                  sh,
                  tq,
                  disable_notify_pipe,
                  notify) == -1)
    ACE_ERROR ((LM_ERROR,
                ACE_TEXT ("%p\n"),
                ACE_TEXT ("ACE_Select_Reactor_T::open ")
                ACE_TEXT ("failed inside ACE_Select_Reactor_T::CTOR")));
}

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.

Definition at line 604 of file Select_Reactor_T.cpp.

{
  ACE_TRACE ("ACE_Select_Reactor_T::~ACE_Select_Reactor_T");
  this->close ();
}

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 ) [virtual]

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

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]`

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

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

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

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

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]`

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

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]`

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]`

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]`

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

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]`

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
	)			`[virtual]`

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]`

int ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >::remove_handler	(	const ACE_Handle_Set &	handle_set,
		ACE_Reactor_Mask	mask
	)			`[virtual]`

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]`

	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

ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN > Class Template Reference

Public Member Functions

Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Detailed Description

template<class ACE_SELECT_REACTOR_TOKEN> class ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<class ACE_SELECT_REACTOR_TOKEN>
class ACE_Select_Reactor_T< ACE_SELECT_REACTOR_TOKEN >