EpochEnforcer.h

Go to the documentation of this file.

#ifndef _MADARA_UTILITY_EPOCHENFORCER_H_
#define _MADARA_UTILITY_EPOCHENFORCER_H_
 
#include <thread>
#include <chrono>
#include "IntTypes.h"
 
namespace madara
{
namespace utility
{
template<typename CLOCK = std::chrono::steady_clock>
class EpochEnforcer
{
public:
  EpochEnforcer(double period, double max_duration = -1)
  {
    start();
    set_period(period);
    set_duration(max_duration);
  }
 
  inline void start(void)
  {
    start_ = CLOCK::now();
    next_ = start_;
  }
 
  inline void set_duration(double duration)
  {
    std::chrono::duration<double> temp_duration(duration);
    auto duration_ns =
        std::chrono::duration_cast<std::chrono::nanoseconds>(temp_duration);
 
    max_ = start_ + duration_ns;
  }
 
  inline void set_period(double period)
  {
    std::chrono::duration<double> temp_period(period);
    period_ = std::chrono::duration_cast<std::chrono::nanoseconds>(temp_period);
 
    next_ = start_ + period_;
  }
 
  inline void advance_next(void)
  {
    auto current_time = CLOCK::now();
 
    while (next_ <= current_time)
      next_ += period_;
  }
 
  inline bool has_reached_next(void) const
  {
    auto current_time = CLOCK::now();
 
    return current_time >= next_;
  }
 
  inline void sleep_until_next(void)
  {
    std::this_thread::sleep_until(next_);
 
    advance_next();
  }
 
  inline bool is_done(void) const
  {
    return CLOCK::now() >= max_;
  }
 
  inline uint64_t duration_ns(void) const
  {
    auto dur = std::chrono::duration_cast<std::chrono::nanoseconds>(
        CLOCK::now() - start_);
 
    return (uint64_t)dur.count();
  }
 
  inline uint64_t duration_s(void) const
  {
    auto dur =
        std::chrono::duration_cast<std::chrono::seconds>(CLOCK::now() - start_);
 
    return (uint64_t)dur.count();
  }
 
  inline double duration_ds(void) const
  {
    auto dur = std::chrono::duration_cast<std::chrono::duration<double>>(
        CLOCK::now() - start_);
 
    return (double)dur.count();
  }
 
  template<typename PERIOD = std::chrono::nanoseconds>
  inline uint64_t duration(void) const
  {
    auto dur = std::chrono::duration_cast<PERIOD>(CLOCK::now() - start_);
 
    return (uint64_t)dur.count();
  }
 
private:
  std::chrono::time_point<CLOCK> start_;
 
  std::chrono::time_point<CLOCK> max_;
 
  std::chrono::time_point<CLOCK> next_;
 
  std::chrono::nanoseconds period_;
};
}
}
 
#endif  // _MADARA_UTILITY_EPOCHENFORCER_H_