periodic_timer.hpp

 
#ifndef PERIODIC_TIMER_HPP_INCLUDED
#define PERIODIC_TIMER_HPP_INCLUDED
 
#include "asio/basic_waitable_timer.hpp"
#include "asio/io_context.hpp"
 
#include <chrono>
#include <system_error>
#include <utility> // std::move, std::forward
 
namespace chops {
 
template <typename Clock = std::chrono::steady_clock>
class periodic_timer {
public:
 
  using duration = typename Clock::duration;
  using time_point = typename Clock::time_point;
 
private:
 
  asio::basic_waitable_timer<Clock> m_timer;
 
private:
  template <typename F>
  void duration_handler_impl(const time_point& last_tp, const duration& dur, 
                             const std::error_code& err, F&& func) {
    time_point now_time { Clock::now() };
    // pass err and elapsed time to app function obj
    if (!func(err, now_time - last_tp) || 
        err == asio::error::operation_aborted) {
      return; // app is finished with timer for now or timer was cancelled
    }
    m_timer.expires_after(dur);
    m_timer.async_wait( [now_time, dur, f = std::move(func), this]
            (const std::error_code& e) {
        duration_handler_impl(now_time, dur, e, std::move(f));
      }
    );
  }
  template <typename F>
  void timepoint_handler_impl(const time_point& last_tp, const duration& dur, 
                              const std::error_code& err, F&& func) {
    // pass err and elapsed time to app function obj
    if (!func(err, (Clock::now() - last_tp)) || 
        err == asio::error::operation_aborted) {
      return; // app is finished with timer for now or timer was cancelled
    }
    m_timer.expires_at(last_tp + dur + dur);
    m_timer.async_wait( [f = std::move(func), last_tp, dur, this]
            (const std::error_code& e) {
        timepoint_handler_impl(last_tp+dur, dur, e, std::move(f));
      }
    );
  }
 
public:
 
  explicit periodic_timer(asio::io_context& ioc) noexcept : m_timer(ioc) { }
 
  periodic_timer() = delete; // no default ctor
 
  // disallow copy construction and copy assignment
  periodic_timer(const periodic_timer&) = delete;
  periodic_timer& operator=(const periodic_timer&) = delete;
 
  // allow move construction and move assignment
  periodic_timer(periodic_timer&&) = default;
  periodic_timer& operator=(periodic_timer&& rhs) {
    m_timer.cancel();
    m_timer = std::move(rhs.m_timer);
  }
 
  // modifying methods
 
  template <typename F>
  void start_duration_timer(const duration& dur, F&& func) {
    m_timer.expires_after(dur);
    m_timer.async_wait( [dur, f = std::move(func), this] (const std::error_code& e) {
        duration_handler_impl(Clock::now(), dur, e, std::move(f));
      }
    );
  }
  template <typename F>
  void start_duration_timer(const duration& dur, const time_point& when, F&& func) {
    m_timer.expires_at(when);
    m_timer.async_wait( [dur, f = std::move(func), this] (const std::error_code& e) {
        duration_handler_impl(Clock::now(), dur, e, std::move(f));
      }
    );
  }
  template <typename F>
  void start_timepoint_timer(const duration& dur, F&& func) {
    start_timepoint_timer(dur, (Clock::now() + dur), std::forward<F>(func));
  }
  template <typename F>
  void start_timepoint_timer(const duration& dur, const time_point& when, F&& func) {
    m_timer.expires_at(when);
    m_timer.async_wait( [when, dur, f = std::move(func), this]
            (const std::error_code& e) {
        timepoint_handler_impl((when-dur), dur, e, std::move(f));
      }
    );
  }
 
  void cancel() {
    m_timer.cancel();
  }
};
 
} // end namespace
 
#endif