void
device_averager::deactivate()
{
doit( device_state::command_off );
ACE_Reactor * reactor = acewrapper::singleton::ReactorThread::instance()->get_reactor();
reactor->cancel_timer( this );
}
void
Sender_exec_i::stop (void)
{
ACE_Reactor* reactor = 0;
::CORBA::Object_var ccm_object = this->ciao_context_->get_CCM_object();
if (!::CORBA::is_nil (ccm_object.in ()))
{
::CORBA::ORB_var orb = ccm_object->_get_orb ();
if (!::CORBA::is_nil (orb.in ()))
{
reactor = orb->orb_core ()->reactor ();
}
}
if (reactor)
{
reactor->cancel_timer (this->ticker_);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("Sender_exec_i::stop : Timer canceled.\n")));
}
else
{
throw ::CORBA::INTERNAL ();
}
if (!this->ready_to_start_.value())
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Sender_exec_i::stop - ")
ACE_TEXT ("Sender never got ready to start\n")));
}
}
void
Heartbeat_Application::stop_timeouts (void)
{
ACE_Reactor *reactor = this->orb_->orb_core ()->reactor ();
if (!reactor
|| reactor->cancel_timer (&this->timeout_handler_) == -1)
{
ACE_ERROR ((LM_ERROR,
"Heartbeat_Application::stop_timeouts - "
"cannot deregister from reactor.\n"));
}
}
int
Time_Handler::svc (void)
{
ACE_Reactor *r = ACE_Reactor::instance ();
ACE_TEST_ASSERT (r->cancel_timer (this->timer_id_[2]) == 1);
this->timer_id_[2] = Time_Handler::TIMER_CANCELLED;
this->timer_id_[1] = r->schedule_timer(this,
(const void *) 1,
ACE_Time_Value (2));
// This one may get the callback before we return, so serialize.
this->lock_.acquire ();
this->timer_id_[0] = r->schedule_timer(this,
(const void *) 0,
ACE_Time_Value (0, -5));
this->lock_.release ();
ACE_OS::sleep(3);
this->timer_id_[5] = r->schedule_timer(this,
(const void *)5,
ACE_Time_Value (10));
this->timer_id_[6] = r->schedule_timer(this,
(const void *)6,
ACE_Time_Value (12));
ACE_TEST_ASSERT (r->cancel_timer (this->timer_id_[4]) == 1);
this->timer_id_[4] = Time_Handler::TIMER_CANCELLED;
// Test that cancelling a timers through a nill ACE_Event_Handler
// pointer just does nothing instead of crash
ACE_Event_Handler_var timer_var;
ACE_TEST_ASSERT (r->cancel_timer (timer_var.handler()) == 0);
return 0;
}
int main (int, char* [])
{
ACE_Reactor reactor;
Time_Handler* th = new Time_Handler;
int timer_id[NUMBER_TIMERS];
for (int i = 0; i < NUMBER_TIMERS; i++)
{
timer_id[i] = reactor.schedule_timer(th,
(const void *)i, // argument sent to handle_timeout()
ACE_Time_Value(2 * i + 1)); //set timer to go off with delay
}
//Cancel the fifth timer before it goes off
reactor.cancel_timer(timer_id[5]);//Timer ID of timer to be removed
while (!done)
{
reactor.handle_events();
}
return 0;
}
static bool
test_reactor_dispatch_order (ACE_Reactor &reactor)
{
Handler handler (reactor);
if (!handler.ok_)
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Error initializing test; abort.\n")));
return false;
}
bool ok_to_go = true;
// This should trigger a call to <handle_input>.
ssize_t result =
ACE::send_n (handler.pipe_.write_handle (),
message,
ACE_OS::strlen (message));
if (result != ssize_t (ACE_OS::strlen (message)))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("Handler sent %b bytes; should be %B\n"),
result, ACE_OS::strlen (message)));
ok_to_go = false;
}
// This should trigger a call to <handle_timeout>.
if (-1 == reactor.schedule_timer (&handler,
0,
ACE_Time_Value (0)))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("schedule_timer")));
ok_to_go = false;
}
// Suspend the handlers - only the timer should be dispatched
ACE_Time_Value tv (1);
reactor.suspend_handlers ();
if (0 != reactor.run_reactor_event_loop (tv))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("run_reactor_event_loop")));
ok_to_go = false;
}
// only the timer should have fired
if (handler.dispatch_order_ != 2)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Incorrect number fired %d; expected 2\n"),
handler.dispatch_order_));
ok_to_go = false;
}
// Reset the dispatch_order_ count and schedule another timer
handler.dispatch_order_ = 1;
if (-1 == reactor.schedule_timer (&handler,
0,
ACE_Time_Value (0)))
{
ACE_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("schedule_timer")));
ok_to_go = false;
}
// Resume the handlers - things should work now
reactor.resume_handlers ();
if (ok_to_go)
{
if (0 != reactor.run_reactor_event_loop (tv))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("run_reactor_event_loop 2")));
ok_to_go = false;
}
}
if (0 != reactor.remove_handler (handler.pipe_.read_handle (),
ACE_Event_Handler::ALL_EVENTS_MASK |
ACE_Event_Handler::DONT_CALL))
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("%p\n"),
ACE_TEXT ("remover_handler pipe")));
if (handler.dispatch_order_ != 4)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Incorrect number fired %d; expected 4\n"),
handler.dispatch_order_));
ok_to_go = false;
}
int nr_cancelled = reactor.cancel_timer (&handler);
if (nr_cancelled > 0)
ACE_ERROR ((LM_ERROR,
ACE_TEXT ("Finishing test with %d timers still scheduled\n"),
nr_cancelled));
return ok_to_go;
}
int
Time_Handler::svc (void)
{
ACE_Reactor *r = ACE_Reactor::instance ();
ACE_ASSERT (r->cancel_timer (this->timer_id_[2]) == 1);
this->timer_id_[2] = Time_Handler::TIMER_CANCELLED;
this->timer_id_[1] = r->schedule_timer(this,
(const void *) 1,
ACE_Time_Value (2));
// This one may get the callback before we return, so serialize.
this->lock_.acquire ();
this->timer_id_[0] = r->schedule_timer(this,
(const void *) 0,
ACE_Time_Value (0, -5));
this->lock_.release ();
ACE_OS::sleep(3);
this->timer_id_[5] = r->schedule_timer(this,
(const void *)5,
ACE_Time_Value (10));
this->timer_id_[6] = r->schedule_timer(this,
(const void *)6,
ACE_Time_Value (12));
ACE_ASSERT (r->cancel_timer (this->timer_id_[4]) == 1);
this->timer_id_[4] = Time_Handler::TIMER_CANCELLED;
return 0;
}
