/home/mhx/git/github/libmoost/include/moost/utils/fixed_interval_timer.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_FIXED_INTERVAL_TIMER_TIMER_HPP__
#define MOOST_FIXED_INTERVAL_TIMER_TIMER_HPP__

#include <csignal>
#include <utility>
#include <boost/function.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/asio.hpp>
#include <boost/ref.hpp>

namespace moost { namespace utils {

   class fixed_interval_timer
   {
      private:
         typedef boost::promise<int> promise_t;
         typedef boost::shared_ptr<promise_t> promise_ptr;
         typedef std::sig_atomic_t volatile sig_atomic_t;
         typedef boost::shared_ptr<sig_atomic_t> signal_ptr;

      public:
         typedef boost::function0<void> callback_t;
         typedef std::pair<boost::posix_time::ptime, callback_t> process_arg;

         fixed_interval_timer(boost::posix_time::time_duration const & interval)
            : interval_(interval)
            , thread_(boost::bind(&boost::asio::io_service::run, &io_service_))
            , pwork_(new boost::asio::io_service::work(io_service_))
         {
         }

         ~fixed_interval_timer()
         {
            try
            {
               // right, down tools chaps
               pwork_.reset();
               thread_.join();
            }
            catch(...)
            {
               // oh, crap :(
            }
         }

         void notify(callback_t const & cb)
         {
            // notify me when this time has passed
            boost::posix_time::ptime pt =
               boost::posix_time::microsec_clock::universal_time() + interval_;

            // queue the notification request
            io_service_.post(boost::bind(
               &fixed_interval_timer::process, this,
               std::make_pair(pt, cb)));
         }

         typedef boost::unique_future<int> future_t;

         void notify(future_t & f_sig)
         {
            // signal me when this time has passed
            boost::posix_time::ptime pt =
               boost::posix_time::microsec_clock::universal_time() + interval_;

            // I promise to notify you in the future
            promise_ptr p_sig(new promise_t);
            f_sig = p_sig->get_future();

            // queue the notification request
            io_service_.post(boost::bind(
               &fixed_interval_timer::process, this,
               std::make_pair(pt, boost::bind(
                  &fixed_interval_timer::fulfil_promise, this, p_sig))
               ));
         }


         class signal_t
         {
            friend class fixed_interval_timer;

            public:
               signal_t()
                  : psig_(new sig_atomic_t(0)) {}

               bool is_ready() const
               {
                  return *psig_ == 1;
               }

            private:
               signal_ptr psig_;
         };

         void notify(signal_t & sig)
         {
            // signal me when this time has passed
            boost::posix_time::ptime pt =
               boost::posix_time::microsec_clock::universal_time() + interval_;

            // queue the signal request
            io_service_.post(boost::bind(
               &fixed_interval_timer::process, this,
               std::make_pair(pt, boost::bind(
                  &fixed_interval_timer::set_signal, this, sig.psig_))
               ));
         }


      private:
         // process the current queue item
         void process(process_arg const & arg) const
         {
            // sleep until it's time to call the callback
            boost::thread::sleep(arg.first);

            // call the callback
            arg.second();
         }

         // make good on our promise
         void fulfil_promise(promise_ptr p_sig) const
         {
            // a promise should never be broken!
            p_sig->set_value(1);
         }

         // signal that sucker
         void set_signal(signal_ptr psig) const
         {
            *psig = 1;
         }

      private:
         boost::posix_time::time_duration interval_;
         boost::asio::io_service io_service_;
         boost::thread thread_;
         boost::shared_ptr<boost::asio::io_service::work> pwork_;
   };

}}

#endif