ACE_Reactor Class ReferenceThis class forwards all methods to its delegation/implementation class, e.g., ACE_Select_Reactor or ACE_WFMO_Reactor. More...
Inheritance diagram for ACE_Reactor:
Collaboration diagram for ACE_Reactor:
Detailed DescriptionThis class forwards all methods to its delegation/implementation class, e.g., ACE_Select_Reactor or ACE_WFMO_Reactor.Member Typedef Documentation
You can specify a hook function to event-handling methods that will be called after each iteration of event handling. If the hook function returns a non-zero value, the event loop will immediately resume waiting for the next event(s) to process without checking the error status of the just-completed iteration of event handling or the end-of-loop indication. If the hook function returns 0, the event handling error status and the end-of-loop indication will be checked as normal, just as if there is no hook function specified.
Member Enumeration Documentation
Operations on the "ready" mask and the "dispatch" mask.
Constructor & Destructor Documentation
Create the Reactor using implementation. The flag delete_implementation tells the Reactor whether or not to delete the implementation on destruction.
Close down and release all resources. Any notifications that remain queued on this reactor instance are lost.
Deny access since member-wise won't work...
Member Function Documentation
Get pointer to a process-wide ACE_Reactor.
Set pointer to a process-wide ACE_Reactor and return existing pointer. If delete_reactor == true then we'll delete the Reactor at destruction time.
Delete the dynamically allocated Singleton.
Name of the dll in which the dll lives.
Name of the component--ACE_Reactor in this case.
Run the event loop until the <ACE_Reactor::handle_events/ACE_Reactoralertable_handle_events> method returns -1 or the <end_event_loop> method is invoked. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to run another reactor use <ACE_Reactor::run_reactor_event_loop>.
Run the event loop until the <ACE_Reactor::handle_events> or <ACE_Reactor::alertable_handle_events> methods returns -1, the <end_event_loop> method is invoked, or the ACE_Time_Value expires. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to run another reactor use <ACE_Reactor::run_reactor_event_loop>.
Instruct the <ACE_Reactor::instance> to terminate its event loop and notifies the <ACE_Reactor::instance> so that it can wake up and close down gracefully. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to terminate another reactor, use <ACE_Reactor::end_reactor_event_loop>.
Report if the <ACE_Reactor::instance>'s event loop is finished. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to check another reactor use <ACE_Reactor::reactor_event_loop_done>.
Resets the <ACE_Reactor::end_event_loop_> static so that the <run_event_loop> method can be restarted. Note that this method can only be used by the singleton <ACE_Reactor::instance>. Thus, to reset another reactor use <ACE_Reactor::reset_reactor_event_loop>.
The singleton reactor is used by the ACE_Service_Config. Therefore, we must check for the reconfiguration request and handle it after handling an event.
Run the event loop until the <ACE_Reactor::handle_events/ACE_Reactoralertable_handle_events> method returns -1 or the <end_reactor_event_loop> method is invoked.
Run the event loop until the <ACE_Reactor::handle_events> or <ACE_Reactor::alertable_handle_events> methods returns -1, the <end_reactor_event_loop> method is invoked, or the ACE_Time_Value expires.
Instruct the Reactor to terminate its event loop and notifies the Reactor so that it can wake up and deactivate itself. Deactivating the Reactor would allow the Reactor to be shutdown gracefully. Internally the Reactor calls deactivate () on the underlying implementation. Any queued notifications remain queued on return from this method. If the event loop is restarted in the future, the notifications will be dispatched then. If the reactor is closed or deleted without further dispatching, the notifications will be lost.
Indicate if the Reactor's event loop has been ended.
Resets the <ACE_Reactor::end_event_loop_> static so that the <run_event_loop> method can be restarted.
Initialize the ACE_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.
Use a user specified signal handler instead.
Set a user-specified timer queue.
Return the current ACE_Timer_Queue.
Close down and release all resources.
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".
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 timers and I/O 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.
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.
Register handler for I/O events. A handler can be associated with multiple handles. A handle cannot be associated with multiple handlers. The handle will come from ACE_Event_Handler::get_handle(). Reactor will call ACE_Event_Handler::add_reference() for a new handler/handle pair. If this handler/handle pair has already been registered, any new masks specified will be added. In this case, ACE_Event_Handler::add_reference() will not be called. If the registered handler is currently suspended, it will remain suspended. When the handler is resumed, it will have the existing masks plus any masks added through this call. Handlers do not have partial suspensions.
Register handler for I/O events. Same as register_handler(ACE_Event_Handler*,ACE_Reactor_Mask), except handle is explicitly specified.
Register handler for OS events. Register an event_handler that will be notified when <event_handle> is signaled. This will call back its <handle_signal> hook method. Reactor will call ACE_Event_Handler::add_reference() for a new handler/handle pair. This interface is only available Win32 platforms because ACE_HANDLE is an int on non-Win32 platforms and compilers are not able to tell the difference between register_handler(ACE_Event_Handler*,ACE_Reactor_Mask) and register_handler(ACE_Event_Handler*,ACE_HANDLE).
Register handler for I/O events. Similar to register_handler(ACE_HANDLE,ACE_Event_Handler*,ACE_Reactor_Mask), except that the user gets to specify the event handle that will be used for this registration. This only applies to Reactors that use event handles for I/O registrations.
Register handler for multiple I/O events. Shorthand for calling register_handler(ACE_HANDLE,ACE_Event_Handler*,ACE_Reactor_Mask), multiple times for the same event_handler and masks but different <handles>.
Register handler for signals. 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. Reactor will call ACE_Event_Handler::add_reference() on new_sh and ACE_Event_Handler::remove_reference() on old_sh.
Register handler for multiple signals. Shorthand for calling register_handler(int,ACE_Event_Handler*,ACE_Sig_Action*,ACE_Event_Handler**,ACE_Sig_Action*) multiple times for the same event_handler and sig_action but different <signals>.
Remove masks from handle registration. For I/O handles, masks are removed from the Reactor. Unless masks includes ACE_Event_Handler::DONT_CALL, ACE_Event_Handler::handle_close() will be called with the masks that have been removed. If all masks have been removed, ACE_Event_Handler::remove_reference() will be called. For OS handles, the handle is removed from the Reactor. Unless masks includes ACE_Event_Handler::DONT_CALL, ACE_Event_Handler::handle_close() will be called with ACE_Event_Handler::NULL_MASK. ACE_Event_Handler::remove_reference() will also be called.
Remove masks from event_handler registration. Same as remove_handler(ACE_HANDLE,ACE_Reactor_Mask), except handle comes from ACE_Event_Handler::get_handle().
Remove masks from multiple <handle> registrations. Shorthand for calling remove_handler(ACE_HANDLE,ACE_Reactor_Mask) multiple times for the same masks but different handles.
Remove signal handler registration. 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). Note that, unlike removing handler for I/O events, ACE_Event_Handler::handle_close() will not be called when the handler is removed. Neither will any reference-counting activity be involved.
Remove multiple signal handler registrations. Shorthand for calling remove_handler(int,ACE_Sig_Action*,ACE_Sig_Action*,int) multiple times for every signal in sigset.
Suspend handle temporarily.
Suspend event_handler temporarily. Handle is obtained from ACE_Event_Handler::get_handle().
Suspend handles temporarily. Shorthand for calling suspend_handler(ACE_HANDLE) with multiple handles.
Suspend all registered handles temporarily.
Resume handle.
Resume event_handler. Handle is obtained from ACE_Event_Handler::get_handle().
Resume handles. Shorthand for calling resume_handler(ACE_HANDLE) with multiple <handles>.
Resume all registered handles.
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.
Schedule a timer event. Schedule a timer event that will expire after an <delay> 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. Reactor will call ACE_Event_Handler::add_reference() on the handler. After the timeout occurs and ACE_Event_Handler::handle_timeout() has completed, the handler will be implicitly removed from the Reactor and ACE_Event_Handler::remove_reference() will be called.
Implements ACE_Reactor_Timer_Interface.
Reset recurring timer interval. 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. This change will not take effect until the next timeout. Implements ACE_Reactor_Timer_Interface.
Cancel timer. Cancel timer associated with timer_id that was returned from the schedule_timer() method. If arg is non-NULL then it will be set to point to the ``magic cookie'' argument passed in when the 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. On successful cancellation, ACE_Event_Handler::handle_close() will be called with ACE_Event_Handler::TIMER_MASK. ACE_Event_Handler::remove_reference() will also be called. Implements ACE_Reactor_Timer_Interface.
Cancel all timers associated with event handler. Shorthand for calling cancel_timer(long,const void **,int) multiple times for all timer associated with event_handler. ACE_Event_Handler::handle_close() will be called with ACE_Event_Handler::TIMER_MASK only once irrespective of the number of timers associated with the event handler. ACE_Event_Handler::remove_reference() will also be called once for every timer associated with the event handler. Returns number of handlers cancelled. Implements ACE_Reactor_Timer_Interface.
Add masks_to_be_added to the event_handler's entry. event_handler must already have been registered. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.
Add masks_to_be_added to the handle's entry. <event_handler> associated with handle must already have been registered. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.
Clear masks_to_be_cleared from the event_handler's entry. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.
Clear masks_to_be_cleared from the <handle>'s entry. Note that this call does not cause the Reactor to re-examine its set of handlers - the new masks will be noticed the next time the Reactor waits for activity. If there is no other activity expected, or you need immediate re-examination of the wait masks, either call ACE_Reactor::notify after this call, or use ACE_Reactor::register_handler instead.
Dispatch user specified events. Handler will be dispatched irrespective of whether it is registered, not registered, or suspended in the Reactor. If user specified event is successfully queued, ACE_Event_Handler::add_reference() will be called. After the notify occurs and the upcall to the handler completes, the handler will be implicitly removed from the Reactor and ACE_Event_Handler::remove_reference() will be called. No other upcall reference counting is done. For I/O or OS events, the upcall is invoked with an ACE_INVALID_HANDLE. For timer events, the upcall is invoked with a null ACT.
Set the maximum number of times that ACE_Reactor 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.
Get the maximum number of times that the ACE_Reactor will iterate and dispatch the ACE_Event_Handler's that are passed in via the notify queue before breaking out of its <ACE_Message_Queue::dequeue> loop.
Purge any notifications pending in this reactor for the specified ACE_Event_Handler object. If eh == 0, all notifications for all handlers are removed (but not any notifications posted just to wake up the reactor itself). Returns the number of notifications purged. Returns -1 on error. After the purging occurs, the handler will be implicitly removed from the Reactor and ACE_Event_Handler::remove_reference() will be called.
Return the Event_Handler associated with handle. Return 0 if handle is not registered. Reactor will call ACE_Event_Handler::add_reference() on the handler before returning it.
Check to see if handle is associated with a valid Event_Handler bound to mask. Return the Reactor will call ACE_Event_Handler::add_reference() on the handler before returning it if event_handler != 0.
Check to see if signum is associated with a valid Event_Handler bound to a signal. Return the event_handler associated with this
Returns true if Reactor has been successfully initialized, else false.
Returns the current size of the Reactor's internal descriptor table.
Returns a reference to the Reactor's internal lock.
Wake up all threads in waiting in the event loop.
Transfers ownership of Reactor to the new_owner.
Return the ID of the "owner" thread.
Set position of the owner thread.
Get position of the owner thread.
Get the existing restart value.
Set a new value for restart and return the original value.
GET/SET/ADD/CLR the dispatch mask "bit" bound with the event_handler and mask.
GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle and mask.
GET/SET/ADD/CLR the ready "bit" bound with the event_handler and mask.
GET/SET/ADD/CLR the ready "bit" bound with the <handle> and mask.
Get the implementation class.
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. Used for CLASSIX Reactor implementation.
Return 1 if we any event associations were made by the reactor for the handles that it waits on, 0 otherwise.
Dump the state of the object.
Set the implementation class.
Member Data DocumentationDeclare the dynamic allocation hooks.
Delegation/implementation class that all methods will be forwarded to.
Flag used to indicate whether we are responsible for cleaning up the implementation instance
Pointer to a process-wide ACE_Reactor singleton.
Must delete the reactor_ singleton if true.
The documentation for this class was generated from the following files: Generated on Mon Sep 15 07:16:21 2008 for ACE by  1.5.5
| |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||