A Reactor implementation that uses the FOX toolkit (www.fox-toolkit.org) for event demultiplexing. This will let us integrate the FOX toolkit with ACE and/or TAO. More...
#include <FoxReactor.h>
Public Member Functions | |
| ACE_FoxReactor (FXApp *a=0, size_t size=DEFAULT_SIZE, bool restart=false, ACE_Sig_Handler *=0) | |
| virtual | ~ACE_FoxReactor (void) |
| void | fxapplication (FXApp *a) |
| 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) |
| long | onFileEvents (FXObject *, FXSelector, void *) |
| long | onTimerEvents (FXObject *, FXSelector, void *) |
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. | |
| int | FoxWaitForMultipleEvents (int, ACE_Select_Reactor_Handle_Set &, ACE_Time_Value *) |
Private Member Functions | |
| void | reset_timeout (void) |
| ACE_FoxReactor (const ACE_FoxReactor &) | |
| Deny access since member-wise won't work... | |
| ACE_FoxReactor & | operator= (const ACE_FoxReactor &) |
Private Attributes | |
| FXApp * | fxapp |
A Reactor implementation that uses the FOX toolkit (www.fox-toolkit.org) for event demultiplexing. This will let us integrate the FOX toolkit with ACE and/or TAO.
Definition at line 41 of file FoxReactor.h.
| ACE_FoxReactor::ACE_FoxReactor | ( | FXApp * | a = 0, |
|
| size_t | size = DEFAULT_SIZE, |
|||
| bool | restart = false, |
|||
| ACE_Sig_Handler * | h = 0 | |||
| ) |
Definition at line 21 of file FoxReactor.cpp.
: ACE_Select_Reactor (size, restart, h), fxapp(a) { // When the ACE_Select_Reactor is constructed it creates the notify // pipe and registers it with the register_handler_i() method. The // FoxReactor 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 FoxReactor register_handler_i(). This means // that the notify pipe is registered with the ACE_Select_Reactor // event handling code not the FoxReactor and so notfications don't // work. To get around this we simply close and re-opened the // notification handler in the constructor of the FoxReactor. #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) this->notify_handler_->close (); this->notify_handler_->open (this, 0); #endif /* ACE_MT_SAFE */ }
| ACE_FoxReactor::~ACE_FoxReactor | ( | void | ) | [virtual] |
Definition at line 44 of file FoxReactor.cpp.
{
}
| ACE_FoxReactor::ACE_FoxReactor | ( | const ACE_FoxReactor & | ) | [private] |
Deny access since member-wise won't work...
| int ACE_FoxReactor::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 299 of file FoxReactor.cpp.
{
ACE_TRACE ("ACE_FoxReactor::cancel_timer");
if (ACE_Select_Reactor::cancel_timer (handler,
dont_call_handle_close) == -1)
return -1;
else
{
this->reset_timeout ();
return 0;
}
}
| int ACE_FoxReactor::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 315 of file FoxReactor.cpp.
{
ACE_TRACE ("ACE_FoxReactor::cancel_timer");
if (ACE_Select_Reactor::cancel_timer (timer_id,
arg,
dont_call_handle_close) == -1)
return -1;
else
{
this->reset_timeout ();
return 0;
}
}
| int ACE_FoxReactor::FoxWaitForMultipleEvents | ( | int | width, | |
| ACE_Select_Reactor_Handle_Set & | wait_set, | |||
| ACE_Time_Value * | ||||
| ) | [protected] |
Definition at line 91 of file FoxReactor.cpp.
{
// Check to make sure our handle's are all usable.
ACE_Select_Reactor_Handle_Set temp_set = wait_set;
if (ACE_OS::select (width,
temp_set.rd_mask_,
temp_set.wr_mask_,
temp_set.ex_mask_,
(ACE_Time_Value *) &ACE_Time_Value::zero ) == -1)
return -1; // Bad file arguments...
// Qt processing.
this->fxapp->runOneEvent () ;
// Reset the width, in case it changed during the upcalls.
width = handler_rep_.max_handlep1 ();
// Now actually read the result needed by the <Select_Reactor> using
// <select>.
return ACE_OS::select(width,
wait_set.rd_mask_,
wait_set.wr_mask_,
wait_set.ex_mask_,
(ACE_Time_Value *) &ACE_Time_Value::zero);
}
| void ACE_FoxReactor::fxapplication | ( | FXApp * | a | ) |
Definition at line 48 of file FoxReactor.cpp.
{
fxapp=a;
}
| long ACE_FoxReactor::onFileEvents | ( | FXObject * | , | |
| FXSelector | se, | |||
| void * | handle | |||
| ) |
Definition at line 121 of file FoxReactor.cpp.
{
FXSelector sel=FXSELTYPE(se);
ACE_Select_Reactor_Handle_Set dispatch_set;
bool f=false;
if(sel==SEL_IO_READ){
dispatch_set.rd_mask_.set_bit(ACE_HANDLE(reinterpret_cast<FXival>(handle)));
f=true;
}
else
if(sel==SEL_IO_WRITE){
dispatch_set.wr_mask_.set_bit(ACE_HANDLE(reinterpret_cast<FXival>(handle)));
f=true;
}
else
if(sel==SEL_IO_EXCEPT){
dispatch_set.ex_mask_.set_bit(ACE_HANDLE(reinterpret_cast<FXival>(handle)));
f=true;
};
if(f) dispatch (1, dispatch_set);
return 1;
}
| long ACE_FoxReactor::onTimerEvents | ( | FXObject * | , | |
| FXSelector | , | |||
| void * | ||||
| ) |
Definition at line 144 of file FoxReactor.cpp.
{
// Deal with any timer events
ACE_Select_Reactor_Handle_Set handle_set;
this->dispatch (0, handle_set );
// Set next timeout signal
this->reset_timeout ();
return 0;
}
| ACE_FoxReactor& ACE_FoxReactor::operator= | ( | const ACE_FoxReactor & | ) | [private] |
| int ACE_FoxReactor::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 157 of file FoxReactor.cpp.
{
ACE_TRACE ("ACE_FoxReactor::register_handler_i");
int result = ACE_Select_Reactor::register_handler_i (handle,
handler, mask);
if (result == -1)
return -1;
unsigned long condition = 0;
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK))
ACE_SET_BITS (condition, FX::INPUT_READ);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK))
ACE_SET_BITS (condition, FX::INPUT_WRITE);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK))
ACE_SET_BITS (condition, FX::INPUT_EXCEPT);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK))
ACE_SET_BITS (condition, FX::INPUT_READ);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK))
{
ACE_SET_BITS (condition, FX::INPUT_WRITE); // connected, you may write
ACE_SET_BITS (condition, FX::INPUT_READ); // connected, you have data/err
}
if (condition != 0)
{
fxapp->addInput(handle,condition,this,0);
}
return 0;
}
| int ACE_FoxReactor::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 192 of file FoxReactor.cpp.
{
return ACE_Select_Reactor::register_handler_i (handles, handler, mask);
}
| int ACE_FoxReactor::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 200 of file FoxReactor.cpp.
{
ACE_TRACE ("ACE_FoxReactor::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.
int condition = 0;
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK))
ACE_SET_BITS (condition, FX::INPUT_READ);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK))
ACE_SET_BITS (condition, FX::INPUT_WRITE);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK))
ACE_SET_BITS (condition, FX::INPUT_EXCEPT);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK))
ACE_SET_BITS (condition, FX::INPUT_READ);
if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK))
{
ACE_SET_BITS (condition, FX::INPUT_WRITE); // connected, you may write
ACE_SET_BITS (condition, FX::INPUT_READ); // connected, you have data/err
}
// First clean up the corresponding X11Input.
fxapp->removeInput ((int)handle,condition); // ACE_reinterpret_cast(int,handle));
// Now let the reactor do its work.
return ACE_Select_Reactor::remove_handler_i (handle, mask);
}
| int ACE_FoxReactor::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 232 of file FoxReactor.cpp.
{
return ACE_Select_Reactor::remove_handler_i (handles, mask);
}
| void ACE_FoxReactor::reset_timeout | ( | void | ) | [private] |
This method ensures there's an Fox timeout for the first timeout in the Reactor's Timer_Queue.
Definition at line 242 of file FoxReactor.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;
fxapp->addTimeout (this, 0, t*1000);
}
}
| int ACE_FoxReactor::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 257 of file FoxReactor.cpp.
{
ACE_TRACE ("ACE_FoxReactor::reset_timer_interval");
ACE_MT (ACE_GUARD_RETURN (ACE_Select_Reactor_Token, ace_mon, this->token_, -1));
int const result =
ACE_Select_Reactor::reset_timer_interval (timer_id,
interval);
if (result == -1)
return -1;
else
{
this->reset_timeout ();
return result;
}
}
| long ACE_FoxReactor::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 277 of file FoxReactor.cpp.
{
ACE_TRACE ("ACE_FoxReactor::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_FoxReactor::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 57 of file FoxReactor.cpp.
{
ACE_TRACE( "ACE_FoxReactor::wait_for_multiple_events" );
int nfound = 0;
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_;
nfound = FoxWaitForMultipleEvents (width,
handle_set,
max_wait_time);
} 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
}
FXApp* ACE_FoxReactor::fxapp [private] |
Definition at line 103 of file FoxReactor.h.
1.7.0