A Reactor implementation that uses the Fast-Light (FL) toolkit for event demultiplexing. This will let us integrate the FL toolkit with ACE and/or TAO. More...
#include <FlReactor.h>
Public Member Functions | |
| ACE_FlReactor (size_t size=DEFAULT_SIZE, bool restart=false, ACE_Sig_Handler *=0) | |
| virtual | ~ACE_FlReactor (void) |
| virtual long | schedule_timer (ACE_Event_Handler *event_handler, const void *arg, const ACE_Time_Value &delay, const ACE_Time_Value &interval) |
| virtual int | reset_timer_interval (long timer_id, const ACE_Time_Value &interval) |
| virtual int | cancel_timer (ACE_Event_Handler *handler, int dont_call_handle_close=1) |
| virtual int | cancel_timer (long timer_id, const void **arg=0, int dont_call_handle_close=1) |
Protected Member Functions | |
| virtual int | register_handler_i (ACE_HANDLE handle, ACE_Event_Handler *handler, ACE_Reactor_Mask mask) |
| Register a single handler. | |
| virtual int | register_handler_i (const ACE_Handle_Set &handles, ACE_Event_Handler *handler, ACE_Reactor_Mask mask) |
| Register a set of <handlers>. | |
| virtual int | remove_handler_i (ACE_HANDLE handle, ACE_Reactor_Mask mask) |
| Remove the <handler> associated with this handle. | |
| virtual int | remove_handler_i (const ACE_Handle_Set &handles, ACE_Reactor_Mask) |
| Remove a set of <handles>. | |
| virtual int | wait_for_multiple_events (ACE_Select_Reactor_Handle_Set &, ACE_Time_Value *) |
| Wait for events to occur. | |
Private Member Functions | |
| void | reset_timeout (void) |
| ACE_FlReactor (const ACE_FlReactor &) | |
| Deny access since member-wise won't work... | |
| ACE_FlReactor & | operator= (const ACE_FlReactor &) |
Static Private Member Functions | |
| static void | fl_io_proc (int fd, void *) |
| static void | fl_timeout_proc (void *) |
A Reactor implementation that uses the Fast-Light (FL) toolkit for event demultiplexing. This will let us integrate the FL toolkit with ACE and/or TAO.
As many other GUI toolkits FL supports a minimal set of callbacks to handle event demultiplexing, namely simple methods to add file descriptors to the event demuxing set or timeout events. This class adapts this simple mechanisms so they are compatible with ACE's Reactor.
Definition at line 46 of file FlReactor.h.
| ACE_FlReactor::ACE_FlReactor | ( | size_t | size = DEFAULT_SIZE, |
|
| bool | restart = false, |
|||
| ACE_Sig_Handler * | h = 0 | |||
| ) |
Definition at line 14 of file FlReactor.cpp.
: ACE_Select_Reactor (size, restart, h) { // When the ACE_Select_Reactor is constructed it creates the notify // pipe and registers it with the register_handler_i() method. The // FlReactor overloads this method BUT because the // register_handler_i occurs when constructing the base class // ACE_Select_Reactor, the ACE_Select_Reactor register_handler_i() // is called not the FlReactor register_handler_i(). This means // that the notify pipe is registered with the ACE_Select_Reactor // event handling code not the FlReactor and so notfications don't // work. To get around this we simply close and re-opened the // notification handler in the constructor of the FlReactor. #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) this->notify_handler_->close (); this->notify_handler_->open (this, 0); #endif /* ACE_MT_SAFE */ }
| ACE_FlReactor::~ACE_FlReactor | ( | void | ) | [virtual] |
Definition at line 36 of file FlReactor.cpp.
{
}
| ACE_FlReactor::ACE_FlReactor | ( | const ACE_FlReactor & | ) | [private] |
Deny access since member-wise won't work...
| int ACE_FlReactor::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.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
Definition at line 297 of file FlReactor.cpp.
{
ACE_TRACE ("ACE_FlReactor::cancel_timer");
if (ACE_Select_Reactor::cancel_timer (handler,
dont_call_handle_close) == -1)
return -1;
else
{
this->reset_timeout ();
return 0;
}
}
| int ACE_FlReactor::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.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
Definition at line 313 of file FlReactor.cpp.
{
ACE_TRACE ("ACE_FlReactor::cancel_timer");
if (ACE_Select_Reactor::cancel_timer (timer_id,
arg,
dont_call_handle_close) == -1)
return -1;
else
{
this->reset_timeout ();
return 0;
}
}
| void ACE_FlReactor::fl_io_proc | ( | int | fd, | |
| void * | reactor | |||
| ) | [static, private] |
Definition at line 108 of file FlReactor.cpp.
{
ACE_FlReactor *self = static_cast<ACE_FlReactor *> (reactor);
ACE_HANDLE handle = (ACE_HANDLE)fd; //reinterpret_cast<ACE_HANDLE> (fd);
// my copy isn't const.
ACE_Time_Value zero = ACE_Time_Value::zero;
ACE_Select_Reactor_Handle_Set wait_set;
// Deal with one file event.
// - read which kind of event
if (self->wait_set_.rd_mask_.is_set (handle))
wait_set.rd_mask_.set_bit (handle);
if (self->wait_set_.wr_mask_.is_set (handle))
wait_set.wr_mask_.set_bit (handle);
if (self->wait_set_.ex_mask_.is_set (handle))
wait_set.ex_mask_.set_bit (handle);
int result = ACE_OS::select (fd + 1,
wait_set.rd_mask_,
wait_set.wr_mask_,
wait_set.ex_mask_, &zero);
ACE_Select_Reactor_Handle_Set dispatch_set;
// - Use only that one file event (removes events for other files).
if (result > 0)
{
if (wait_set.rd_mask_.is_set (handle))
dispatch_set.rd_mask_.set_bit (handle);
if (wait_set.wr_mask_.is_set (handle))
dispatch_set.wr_mask_.set_bit (handle);
if (wait_set.ex_mask_.is_set (handle))
dispatch_set.ex_mask_.set_bit (handle);
self->dispatch (1, dispatch_set);
}
}
| void ACE_FlReactor::fl_timeout_proc | ( | void * | reactor | ) | [static, private] |
Definition at line 150 of file FlReactor.cpp.
{
ACE_FlReactor *self = static_cast<ACE_FlReactor *> (reactor);
// Deal with any timer events
ACE_Select_Reactor_Handle_Set handle_set;
self->dispatch (0, handle_set);
self->reset_timeout ();
}
| ACE_FlReactor& ACE_FlReactor::operator= | ( | const ACE_FlReactor & | ) | [private] |
| int ACE_FlReactor::register_handler_i | ( | const ACE_Handle_Set & | handles, | |
| ACE_Event_Handler * | handler, | |||
| ACE_Reactor_Mask | mask | |||
| ) | [protected, virtual] |
Register a set of <handlers>.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
Definition at line 199 of file FlReactor.cpp.
{
return ACE_Select_Reactor::register_handler_i (handles,
handler,
mask);
}
| int ACE_FlReactor::register_handler_i | ( | ACE_HANDLE | handle, | |
| ACE_Event_Handler * | handler, | |||
| ACE_Reactor_Mask | mask | |||
| ) | [protected, virtual] |
Register a single handler.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
Definition at line 162 of file FlReactor.cpp.
{
ACE_TRACE ("ACE_FlReactor::register_handler_i");
int result = ACE_Select_Reactor::register_handler_i (handle,
handler, mask);
if (result == -1)
return -1;
int condition = 0;
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK))
ACE_SET_BITS (condition, FL_READ);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK))
ACE_SET_BITS (condition, FL_WRITE);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK))
ACE_SET_BITS (condition, FL_EXCEPT);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK))
ACE_SET_BITS (condition, FL_READ);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK))
{
ACE_SET_BITS (condition, FL_WRITE); // connected, you may write
ACE_SET_BITS (condition, FL_READ); // connected, you have data/err
}
if (condition != 0)
{
Fl::add_fd ((int)handle, // reinterpret_cast<int> (handle),
ACE_FlReactor::fl_io_proc,
this);
}
return 0;
}
| int ACE_FlReactor::remove_handler_i | ( | const ACE_Handle_Set & | handles, | |
| ACE_Reactor_Mask | mask | |||
| ) | [protected, virtual] |
Remove a set of <handles>.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
Definition at line 227 of file FlReactor.cpp.
{
return ACE_Select_Reactor::remove_handler_i (handles,
mask);
}
| int ACE_FlReactor::remove_handler_i | ( | ACE_HANDLE | handle, | |
| ACE_Reactor_Mask | mask | |||
| ) | [protected, virtual] |
Remove the <handler> associated with this handle.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
Definition at line 209 of file FlReactor.cpp.
{
ACE_TRACE ("ACE_FlReactor::remove_handler_i");
// In the registration phase we registered first with
// ACE_Select_Reactor and then with X. Now we are now doing things
// in reverse order.
// First clean up the corresponding X11Input.
Fl::remove_fd ((int)handle); // reinterpret_cast<int> (handle);
// Now let the reactor do its work.
return ACE_Select_Reactor::remove_handler_i (handle,
mask);
}
| void ACE_FlReactor::reset_timeout | ( | void | ) | [private] |
This method ensures there's an Fl timeout for the first timeout in the Reactor's Timer_Queue.
Definition at line 238 of file FlReactor.cpp.
{
ACE_Time_Value *max_wait_time =
this->timer_queue_->calculate_timeout (0);
if (max_wait_time != 0)
{
float t = max_wait_time->sec ()
+ max_wait_time->usec () / 1000000.0F;
Fl::add_timeout (t,
ACE_FlReactor::fl_timeout_proc,
this);
}
}
| int ACE_FlReactor::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.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
Definition at line 255 of file FlReactor.cpp.
{
ACE_TRACE ("ACE_FlReactor::reset_timer_interval");
ACE_MT (ACE_GUARD_RETURN (ACE_Select_Reactor_Token, ace_mon, this->token_, -1));
int result =
ACE_Select_Reactor::reset_timer_interval (timer_id,
interval);
if (result == -1)
return -1;
else
{
this->reset_timeout ();
return result;
}
}
| long ACE_FlReactor::schedule_timer | ( | ACE_Event_Handler * | event_handler, | |
| const void * | arg, | |||
| const ACE_Time_Value & | delay, | |||
| const ACE_Time_Value & | interval | |||
| ) | [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.
| 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 |
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
Definition at line 275 of file FlReactor.cpp.
{
ACE_TRACE ("ACE_FlReactor::schedule_timer");
ACE_MT (ACE_GUARD_RETURN (ACE_Select_Reactor_Token, ace_mon, this->token_, -1));
long result = ACE_Select_Reactor::schedule_timer (event_handler,
arg,
delay,
interval);
if (result == -1)
return -1;
else
{
this->reset_timeout ();
return result;
}
}
| int ACE_FlReactor::wait_for_multiple_events | ( | ACE_Select_Reactor_Handle_Set & | handle_set, | |
| ACE_Time_Value * | max_wait_time | |||
| ) | [protected, virtual] |
Wait for events to occur.
Reimplemented from ACE_Select_Reactor_T< ACE_Select_Reactor_Token >.
Definition at line 44 of file FlReactor.cpp.
{
ACE_TRACE ("ACE_FlReactor::wait_for_multiple_events");
int nfound;
do
{
max_wait_time = this->timer_queue_->calculate_timeout (max_wait_time);
size_t width = this->handler_rep_.max_handlep1 ();
handle_set.rd_mask_ = this->wait_set_.rd_mask_;
handle_set.wr_mask_ = this->wait_set_.wr_mask_;
handle_set.ex_mask_ = this->wait_set_.ex_mask_;
// Check to make sure our handle's are all usable.
ACE_Select_Reactor_Handle_Set temp_set = handle_set;
ACE_Time_Value zero = ACE_Time_Value::zero;
if (ACE_OS::select (width,
temp_set.rd_mask_,
temp_set.wr_mask_,
temp_set.ex_mask_,
&zero) == -1)
return -1; // Bad file arguments...
// Instead of waiting using <select>, just use the Fl mechanism
// to wait for one or more events...
// Wait for something to happen.
double t = 0;
if (max_wait_time != 0)
t = max_wait_time->sec () + max_wait_time->usec () / 1000000.0F;
while (t > 0) {
t = Fl::wait (t);
}
// Reset the width, in case it changed during the upcalls.
width = this->handler_rep_.max_handlep1 ();
// Now actually read the result needed by the <Select_Reactor>
// using <select>.
zero = ACE_Time_Value::zero;
nfound = ACE_OS::select (width,
handle_set.rd_mask_,
handle_set.wr_mask_,
handle_set.ex_mask_,
&zero);
} while (nfound == -1 && this->handle_error () > 0);
if (nfound > 0)
{
#if !defined (ACE_WIN32)
handle_set.rd_mask_.sync (this->handler_rep_.max_handlep1 ());
handle_set.wr_mask_.sync (this->handler_rep_.max_handlep1 ());
handle_set.ex_mask_.sync (this->handler_rep_.max_handlep1 ());
#endif /* ACE_WIN32 */
}
return nfound; // Timed out or input available
}
1.7.0