ACE_Single_Input_Reactor Class Reference

#include <Single_Input_Reactor.h>

Inheritance diagram for ACE_Single_Input_Reactor:

Collaboration diagram for ACE_Single_Input_Reactor:

Public Member Functions
int	open (size_t size, bool restart=false, ACE_Sig_Handler *=nullptr, ACE_Timer_Queue *=nullptr, int disable_notify_pipe=0, ACE_Reactor_Notify *=nullptr) override
	Initialization.
int	current_info (ACE_HANDLE, size_t &) override
int	set_sig_handler (ACE_Sig_Handler *signal_handler) override
	Use a user specified signal handler instead.
int	timer_queue (ACE_Timer_Queue *tq) override
	Set a user-specified timer queue.
ACE_Timer_Queue *	timer_queue () const override
	Return the current ACE_Timer_Queue.
int	close () override
	Close down and release all resources.
int	work_pending (const ACE_Time_Value &max_wait_time=ACE_Time_Value::zero) override
int	handle_events (ACE_Time_Value *max_wait_time=nullptr) override
int	alertable_handle_events (ACE_Time_Value *max_wait_time=nullptr) override
int	handle_events (ACE_Time_Value &max_wait_time) override
int	alertable_handle_events (ACE_Time_Value &max_wait_time) override
int	deactivated () override
void	deactivate (int do_stop) override
int	register_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) override
int	register_handler (ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) override
int	register_handler (ACE_Event_Handler *event_handler, ACE_HANDLE event_handle=ACE_INVALID_HANDLE) override
int	register_handler (ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) override
int	register_handler (const ACE_Handle_Set &handles, ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) override
	Register event_handler with all the handles in the Handle_Set.
int	register_handler (int signum, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=nullptr, ACE_Event_Handler **old_sh=nullptr, ACE_Sig_Action *old_disp=nullptr) override
int	register_handler (const ACE_Sig_Set &sigset, ACE_Event_Handler *new_sh, ACE_Sig_Action *new_disp=nullptr) override
int	remove_handler (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask) override
int	remove_handler (ACE_HANDLE handle, ACE_Reactor_Mask mask) override
int	remove_handler (const ACE_Handle_Set &handle_set, ACE_Reactor_Mask mask) override
int	remove_handler (int signum, ACE_Sig_Action *new_disp, ACE_Sig_Action *old_disp=nullptr, int sigkey=-1) override
int	remove_handler (const ACE_Sig_Set &sigset) override
	Calls remove_handler() for every signal in sigset.
int	suspend_handler (ACE_Event_Handler *event_handler) override
int	suspend_handler (ACE_HANDLE handle) override
	Suspend handle temporarily.
int	suspend_handler (const ACE_Handle_Set &handles) override
	Suspend all handles in handle set temporarily.
int	suspend_handlers () override
	Suspend all <handles> temporarily.
int	resume_handler (ACE_Event_Handler *event_handler) override
int	resume_handler (ACE_HANDLE handle) override
	Resume handle.
int	resume_handler (const ACE_Handle_Set &handles) override
	Resume all handles in handle set.
int	resume_handlers () override
	Resume all handles.
int	resumable_handler () override
bool	uses_event_associations () override
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) override
int	reset_timer_interval (long timer_id, const ACE_Time_Value &interval) override
int	cancel_timer (ACE_Event_Handler *event_handler, int dont_call_handle_close=1) override
int	cancel_timer (long timer_id, const void **arg=nullptr, int dont_call_handle_close=1) override
int	schedule_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_added) override
int	schedule_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added) override
int	cancel_wakeup (ACE_Event_Handler *event_handler, ACE_Reactor_Mask masks_to_be_cleared) override
	Clear masks_to_be_cleared from the event_handler's entry.
int	cancel_wakeup (ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_cleared) override
	Clear masks_to_be_cleared from the handle's entry.
int	notify (ACE_Event_Handler *event_handler=nullptr, ACE_Reactor_Mask mask=ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value *=nullptr) override
void	max_notify_iterations (int) override
int	max_notify_iterations () override
int	purge_pending_notifications (ACE_Event_Handler *=nullptr, ACE_Reactor_Mask=ACE_Event_Handler::ALL_EVENTS_MASK) override
ACE_Event_Handler *	find_handler (ACE_HANDLE handle) override
int	handler (ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler **event_handler=nullptr) override
int	handler (int signum, ACE_Event_Handler **event_handler=nullptr) override
bool	initialized () override
size_t	size () const override
ACE_Lock &	lock () override
	Returns a reference to the Reactor's internal lock.
void	wakeup_all_threads () override
	Wake up all threads in waiting in the event loop.
int	owner (ACE_thread_t new_owner, ACE_thread_t *old_owner=nullptr) override
	Transfers ownership of Reactor_Impl to the new_owner.
int	owner (ACE_thread_t *owner) override
	Return the ID of the "owner" thread.
bool	restart () override
	Get the existing restart value.
bool	restart (bool) override
	Set a new value for restart and return the original value.
void	requeue_position (int) override
	Set position of the owner thread.
int	requeue_position () override
	Get position of the owner thread.
int	mask_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops) override
int	mask_ops (ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops) override
int	ready_ops (ACE_Event_Handler *event_handler, ACE_Reactor_Mask mask, int ops) override
int	ready_ops (ACE_HANDLE handle, ACE_Reactor_Mask, int ops) override
	GET/SET/ADD/CLR the ready "bit" bound with the handle and mask.
void	dump () const override
	Dump the state of an object.
Public Member Functions inherited from ACE_Reactor_Impl
virtual	~ACE_Reactor_Impl ()
	Close down and release all resources.

Private Attributes
ACE_Event_Handler_var	event_handler_

Additional Inherited Members
Public Attributes inherited from ACE_Reactor_Impl
	ACE_ALLOC_HOOK_DECLARE
	Declare the dynamic allocation hooks.

Detailed Description

ACE_Single_Input_Reactor is a reactor implementation with extremely limited functionality.

It is designed for use by TAO in cases where there is only a single input to de-multiplex so select() is not needed. The single event handler which is registered will be treated as always ready for input. Other event types (write, exception) are not supported. Handling events with a timeout is not supported. Notification is not supported.

When used by TAO, this reactor is suitable for running on a dedicated thread which will only handle the acceptor's socket (see -ORBConcurrency thread-per-connection).

Member Function Documentation

alertable_handle_events() [1/2]

int ACE_Single_Input_Reactor::alertable_handle_events ( ACE_Time_Value & max_wait_time )

overridevirtual

Implements ACE_Reactor_Impl.

alertable_handle_events() [2/2]

int ACE_Single_Input_Reactor::alertable_handle_events ( ACE_Time_Value * max_wait_time = nullptr )

overridevirtual

Implements ACE_Reactor_Impl.

cancel_timer() [1/2]

int ACE_Single_Input_Reactor::cancel_timer ( ACE_Event_Handler * event_handler, int dont_call_handle_close = 1 )

overridevirtual

Cancel all Event_Handlers that match the address of event_handler. Returns number of handlers cancelled.

Implements ACE_Reactor_Impl.

cancel_timer() [2/2]

int ACE_Single_Input_Reactor::cancel_timer ( long timer_id, const void ** arg = nullptr, int dont_call_handle_close = 1 )

overridevirtual

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.

cancel_wakeup() [1/2]

int ACE_Single_Input_Reactor::cancel_wakeup ( ACE_Event_Handler * event_handler, ACE_Reactor_Mask masks_to_be_cleared )

overridevirtual

Clear masks_to_be_cleared from the event_handler's entry.

Implements ACE_Reactor_Impl.

cancel_wakeup() [2/2]

int ACE_Single_Input_Reactor::cancel_wakeup ( ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_cleared )

overridevirtual

Clear masks_to_be_cleared from the handle's entry.

Implements ACE_Reactor_Impl.

close()

int ACE_Single_Input_Reactor::close ( )

overridevirtual

Close down and release all resources.

Implements ACE_Reactor_Impl.

current_info()

int ACE_Single_Input_Reactor::current_info ( ACE_HANDLE , size_t &  )

overridevirtual

Returns 0, if the size of the current message has been put in size Returns -1, if not. ACE_HANDLE allows the reactor to check if the caller is valid.

Implements ACE_Reactor_Impl.

deactivate()

void ACE_Single_Input_Reactor::deactivate ( int do_stop )

overridevirtual

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.

deactivated()

int ACE_Single_Input_Reactor::deactivated ( )

overridevirtual

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.

dump()

void ACE_Single_Input_Reactor::dump ( ) const

overridevirtual

Dump the state of an object.

Implements ACE_Reactor_Impl.

find_handler()

ACE_Event_Handler * ACE_Single_Input_Reactor::find_handler ( ACE_HANDLE handle )

overridevirtual

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

Implements ACE_Reactor_Impl.

handle_events() [1/2]

int ACE_Single_Input_Reactor::handle_events ( ACE_Time_Value & max_wait_time )

overridevirtual

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, the eventloop will return when the system queues an I/O completion routine or an Asynchronous Procedure Call.

Implements ACE_Reactor_Impl.

handle_events() [2/2]

int ACE_Single_Input_Reactor::handle_events ( ACE_Time_Value * max_wait_time = nullptr )

overridevirtual

This event loop driver blocks for up to max_wait_time before returning. It will return earlier if 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 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, the eventloop will return when the system queues an I/O completion routine or an Asynchronous Procedure Call.

Implements ACE_Reactor_Impl.

handler() [1/2]

int ACE_Single_Input_Reactor::handler ( ACE_HANDLE handle, ACE_Reactor_Mask mask, ACE_Event_Handler ** event_handler = nullptr )

overridevirtual

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.

handler() [2/2]

int ACE_Single_Input_Reactor::handler ( int signum, ACE_Event_Handler ** = nullptr )

overridevirtual

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.

initialized()

bool ACE_Single_Input_Reactor::initialized ( )

overridevirtual

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

Implements ACE_Reactor_Impl.

lock()

ACE_Lock & ACE_Single_Input_Reactor::lock ( )

overridevirtual

Returns a reference to the Reactor's internal lock.

Implements ACE_Reactor_Impl.

mask_ops() [1/2]

int ACE_Single_Input_Reactor::mask_ops ( ACE_Event_Handler * event_handler, ACE_Reactor_Mask mask, int ops )

overridevirtual

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

Implements ACE_Reactor_Impl.

mask_ops() [2/2]

int ACE_Single_Input_Reactor::mask_ops ( ACE_HANDLE handle, ACE_Reactor_Mask mask, int ops )

overridevirtual

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

Implements ACE_Reactor_Impl.

max_notify_iterations() [1/2]

int ACE_Single_Input_Reactor::max_notify_iterations ( )

overridevirtual

Get the maximum number of times that the ACE_Reactor_Impl 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.

max_notify_iterations() [2/2]

void ACE_Single_Input_Reactor::max_notify_iterations ( int )

overridevirtual

Set the maximum number of times that ACE_Reactor_Impl 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.

notify()

int ACE_Single_Input_Reactor::notify ( ACE_Event_Handler * event_handler = nullptr, ACE_Reactor_Mask mask = ACE_Event_Handler::EXCEPT_MASK, ACE_Time_Value * = nullptr )

overridevirtual

Notify event_handler of mask event. The ACE_Time_Value indicates how long to blocking trying to notify. 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.

open()

int ACE_Single_Input_Reactor::open ( size_t size, bool restart = false, ACE_Sig_Handler * = nullptr, ACE_Timer_Queue * = nullptr, int disable_notify_pipe = 0, ACE_Reactor_Notify * = nullptr )

overridevirtual

Initialization.

Implements ACE_Reactor_Impl.

owner() [1/2]

int ACE_Single_Input_Reactor::owner ( ACE_thread_t * owner )

overridevirtual

Return the ID of the "owner" thread.

Implements ACE_Reactor_Impl.

owner() [2/2]

int ACE_Single_Input_Reactor::owner ( ACE_thread_t new_owner, ACE_thread_t * old_owner = nullptr )

overridevirtual

Transfers ownership of Reactor_Impl to the new_owner.

Implements ACE_Reactor_Impl.

purge_pending_notifications()

int ACE_Single_Input_Reactor::purge_pending_notifications ( ACE_Event_Handler * = nullptr, ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK )

overridevirtual

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.

ready_ops() [1/2]

int ACE_Single_Input_Reactor::ready_ops ( ACE_Event_Handler * event_handler, ACE_Reactor_Mask mask, int ops )

overridevirtual

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

Implements ACE_Reactor_Impl.

ready_ops() [2/2]

int ACE_Single_Input_Reactor::ready_ops ( ACE_HANDLE handle, ACE_Reactor_Mask , int ops )

overridevirtual

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

Implements ACE_Reactor_Impl.

register_handler() [1/7]

int ACE_Single_Input_Reactor::register_handler ( ACE_Event_Handler * event_handler, ACE_HANDLE event_handle = ACE_INVALID_HANDLE )

overridevirtual

Register an event_handler that will be notified when event_handle is signaled. Since no event mask is passed through this interface, it is assumed that the event_handler being passed in is an event handle and not an I/O handle.

Implements ACE_Reactor_Impl.

register_handler() [2/7]

int ACE_Single_Input_Reactor::register_handler ( ACE_Event_Handler * event_handler, ACE_Reactor_Mask mask )

overridevirtual

Register event_handler with mask. The I/O handle will always come from get_handle() on the event_handler.

Implements ACE_Reactor_Impl.

register_handler() [3/7]

int ACE_Single_Input_Reactor::register_handler ( ACE_HANDLE event_handle, ACE_HANDLE io_handle, ACE_Event_Handler * event_handler, ACE_Reactor_Mask mask )

overridevirtual

Register an event_handler that will be notified when event_handle is signaled. mask specifies the network events that the event_handler is interested in.

Implements ACE_Reactor_Impl.

register_handler() [4/7]

int ACE_Single_Input_Reactor::register_handler ( ACE_HANDLE io_handle, ACE_Event_Handler * event_handler, ACE_Reactor_Mask mask )

overridevirtual

Register event_handler with mask. The I/O handle is provided through the io_handle parameter.

Implements ACE_Reactor_Impl.

register_handler() [5/7]

int ACE_Single_Input_Reactor::register_handler ( const ACE_Handle_Set & handles, ACE_Event_Handler * event_handler, ACE_Reactor_Mask mask )

overridevirtual

Register event_handler with all the handles in the Handle_Set.

Implements ACE_Reactor_Impl.

register_handler() [6/7]

int ACE_Single_Input_Reactor::register_handler ( const ACE_Sig_Set & sigset, ACE_Event_Handler * new_sh, ACE_Sig_Action * new_disp = nullptr )

overridevirtual

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

Implements ACE_Reactor_Impl.

register_handler() [7/7]

int ACE_Single_Input_Reactor::register_handler ( int signum, ACE_Event_Handler * new_sh, ACE_Sig_Action * new_disp = nullptr, ACE_Event_Handler ** old_sh = nullptr, ACE_Sig_Action * old_disp = nullptr )

overridevirtual

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.

remove_handler() [1/5]

int ACE_Single_Input_Reactor::remove_handler ( ACE_Event_Handler * event_handler, ACE_Reactor_Mask mask )

overridevirtual

Removes event_handler. Note that the I/O handle will be obtained using get_handle() method of event_handler . If mask == ACE_Event_Handler::DONT_CALL then the handle_close() method of the event_handler is not invoked.

Implements ACE_Reactor_Impl.

remove_handler() [2/5]

int ACE_Single_Input_Reactor::remove_handler ( ACE_HANDLE handle, ACE_Reactor_Mask mask )

overridevirtual

Removes handle. If mask == ACE_Event_Handler::DONT_CALL then the handle_close() method of the associated event_handler is not invoked.

Implements ACE_Reactor_Impl.

remove_handler() [3/5]

int ACE_Single_Input_Reactor::remove_handler ( const ACE_Handle_Set & handle_set, ACE_Reactor_Mask mask )

overridevirtual

Removes all handles in handle_set. If mask == ACE_Event_Handler::DONT_CALL then the handle_close() method of the associated event_handlers is not invoked.

Implements ACE_Reactor_Impl.

remove_handler() [4/5]

int ACE_Single_Input_Reactor::remove_handler ( const ACE_Sig_Set & sigset )

overridevirtual

Calls remove_handler() for every signal in sigset.

Implements ACE_Reactor_Impl.

remove_handler() [5/5]

int ACE_Single_Input_Reactor::remove_handler ( int signum, ACE_Sig_Action * new_disp, ACE_Sig_Action * old_disp = nullptr, int sigkey = -1 )

overridevirtual

Remove the ACE_Event_Handler currently associated with signum. 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.

requeue_position() [1/2]

int ACE_Single_Input_Reactor::requeue_position ( )

overridevirtual

Get position of the owner thread.

Implements ACE_Reactor_Impl.

requeue_position() [2/2]

void ACE_Single_Input_Reactor::requeue_position ( int )

overridevirtual

Set position of the owner thread.

Implements ACE_Reactor_Impl.

reset_timer_interval()

int ACE_Single_Input_Reactor::reset_timer_interval ( long timer_id, const ACE_Time_Value & interval )

overridevirtual

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.

restart() [1/2]

bool ACE_Single_Input_Reactor::restart ( )

overridevirtual

Get the existing restart value.

Implements ACE_Reactor_Impl.

restart() [2/2]

bool ACE_Single_Input_Reactor::restart ( bool r )

overridevirtual

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

Implements ACE_Reactor_Impl.

resumable_handler()

int ACE_Single_Input_Reactor::resumable_handler ( )

overridevirtual

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

Implements ACE_Reactor_Impl.

resume_handler() [1/3]

int ACE_Single_Input_Reactor::resume_handler ( ACE_Event_Handler * event_handler )

overridevirtual

Resume event_handler. Uses ACE_Event_Handler::get_handle() to get the handle.

Implements ACE_Reactor_Impl.

resume_handler() [2/3]

int ACE_Single_Input_Reactor::resume_handler ( ACE_HANDLE handle )

overridevirtual

Resume handle.

Implements ACE_Reactor_Impl.

resume_handler() [3/3]

int ACE_Single_Input_Reactor::resume_handler ( const ACE_Handle_Set & handles )

overridevirtual

Resume all handles in handle set.

Implements ACE_Reactor_Impl.

resume_handlers()

int ACE_Single_Input_Reactor::resume_handlers ( )

overridevirtual

Resume all handles.

Implements ACE_Reactor_Impl.

schedule_timer()

long ACE_Single_Input_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 )

overridevirtual

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.

schedule_wakeup() [1/2]

int ACE_Single_Input_Reactor::schedule_wakeup ( ACE_Event_Handler * event_handler, ACE_Reactor_Mask masks_to_be_added )

overridevirtual

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

Implements ACE_Reactor_Impl.

schedule_wakeup() [2/2]

int ACE_Single_Input_Reactor::schedule_wakeup ( ACE_HANDLE handle, ACE_Reactor_Mask masks_to_be_added )

overridevirtual

Add masks_to_be_added to the handle's entry. <event_handler> associated with handle must already have been registered.

Implements ACE_Reactor_Impl.

set_sig_handler()

int ACE_Single_Input_Reactor::set_sig_handler ( ACE_Sig_Handler * signal_handler )

overridevirtual

Use a user specified signal handler instead.

Implements ACE_Reactor_Impl.

size()

size_t ACE_Single_Input_Reactor::size ( ) const

overridevirtual

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

Implements ACE_Reactor_Impl.

suspend_handler() [1/3]

int ACE_Single_Input_Reactor::suspend_handler ( ACE_Event_Handler * event_handler )

overridevirtual

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

Implements ACE_Reactor_Impl.

suspend_handler() [2/3]

int ACE_Single_Input_Reactor::suspend_handler ( ACE_HANDLE handle )

overridevirtual

Suspend handle temporarily.

Implements ACE_Reactor_Impl.

suspend_handler() [3/3]

int ACE_Single_Input_Reactor::suspend_handler ( const ACE_Handle_Set & handles )

overridevirtual

Suspend all handles in handle set temporarily.

Implements ACE_Reactor_Impl.

suspend_handlers()

int ACE_Single_Input_Reactor::suspend_handlers ( )

overridevirtual

Suspend all <handles> temporarily.

Implements ACE_Reactor_Impl.

timer_queue() [1/2]

ACE_Timer_Queue * ACE_Single_Input_Reactor::timer_queue ( ) const

overridevirtual

Return the current ACE_Timer_Queue.

Implements ACE_Reactor_Impl.

timer_queue() [2/2]

int ACE_Single_Input_Reactor::timer_queue ( ACE_Timer_Queue * tq )

overridevirtual

Set a user-specified timer queue.

Implements ACE_Reactor_Impl.

uses_event_associations()

bool ACE_Single_Input_Reactor::uses_event_associations ( )

overridevirtual

Return true if we any event associations were made by the reactor for the handles that it waits on, false otherwise.

Implements ACE_Reactor_Impl.

wakeup_all_threads()

void ACE_Single_Input_Reactor::wakeup_all_threads ( )

overridevirtual

Wake up all threads in waiting in the event loop.

Implements ACE_Reactor_Impl.

work_pending()

int ACE_Single_Input_Reactor::work_pending ( const ACE_Time_Value & max_wait_time = ACE_Time_Value::zero )

overridevirtual

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

event_handler_

ACE_Event_Handler_var ACE_Single_Input_Reactor::event_handler_

private

---

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

• Single_Input_Reactor.h
• Single_Input_Reactor.cpp