Hi all,
I started playing with ASIO timers and after scanning through the relevant
docs, I set up a small case. Please find below the code snippet.
The IntervalEvent class is supposed to fire the event provided on the
construction at a frequency equal to the durationInterval.
Somehow the code below fails to compile on VC7.1.
I am getting several warnings and the error:
c:\program files\boost\boost_1_38\boost\mem_fn.hpp(343) : error C4716:
'boost::_mfi::dm::operator()' : must return a value
I have not tried yet gcc. Probably I am doing something stupid. Any ideas?
Further to that, I am wondering, in principle should I cancel the
deadline_timer on the destructor of the IntervalEvent class? Does the
io_service class know when any of the deadline_timers that is being
registered goes out of scope?
Thank you very much in advance. Any help would be highly appreciated.
Kimon
#include
#include <iostream>
#include
#include
#include
#include
class Counter
{
public:
Counter():m_value(0)
{
}
void onIncrement()
{
++m_value;
std::cout<<"Counter is "< event):
m_intervalDuration(durationSeconds),
m_timer(io,boost::posix_time::seconds(m_intervalDuration)),
m_event(event)
{
//io_service::run is running in only one thread
m_timer.async_wait(boost::bind(&IntervalEvent::handler, this));
}
~IntervalEvent()
{
//should I call m_timer.cancel to notify the io_service?
}
void handler(boost::system::error_code& error)
{
if(error!= boost::asio::error::operation_aborted)
{
m_event();
reset(m_intervalDuration);
}
}
void reset(long duration)
{
if (m_timer.expires_from_now(boost::posix_time::seconds(duration)) >
0)
{
m_intervalDuration = duration;
//reset the async wait
m_timer.async_wait(boost::bind(&IntervalEvent::handler, this));
}
else
{
//Timer already canceled
}
}
void cancel()
{
m_timer.cancel();
}
size_t getCurrentInterval() const
{
return m_intervalDuration;
}
protected:
long m_intervalDuration;
boost::asio::deadline_timer m_timer;
boost::function m_event;
};
int main()
{
boost::asio::io_service io;
boost::shared_ptrboost::asio::io_service::work work(new
boost::asio::io_service::work(io));
boost::thread ioservice_thread(boost::bind(&boost::asio::io_service::run,
&io));
std::vector events;
Counter count;
long duration = 1;
boost::shared_ptr<IntervalEvent> firstEvent(new IntervalEvent(io,
duration,
boost::bind(&Counter::onIncrement,boost::ref(count)
))
);
events.push_back(firstEvent);
char response = 'N';
while(response == 'N')
{
std::cout<<"Create a new interval event? [Y/N]"<>response;
if(response == 'Y')
{
boost::shared_ptr<IntervalEvent> test(new IntervalEvent(io,
duration,
boost::bind(&Counter::onIncrement,boost::ref(count)
))
);
events.push_back(test);
}
}
//cancel interval events
for(std::vector::iterator it =
events.begin(), itEnd = events.end();
it!=itEnd;
++it)
{
(*it)->cancel();
}
//reset ioservice_work
work.reset();
ioservice_thread.join();
return 0;
}
