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)
      {
        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_