Timer.hpp

Go to the documentation of this file.

#ifndef SOLIDUTILS_INCLUDE_TIMER_HPP
#define SOLIDUTILS_INCLUDE_TIMER_HPP


#include <chrono>
#include <memory>
#include <stdexcept>


namespace sl
{

class Timer
{
  public:
    static double now()
    {
      std::chrono::high_resolution_clock::time_point time =
          std::chrono::high_resolution_clock::now();
                        size_t const ticks = \
          static_cast<size_t>(time.time_since_epoch().count());
                        double constexpr SECONDS_PER_TICK = \
                                        static_cast<double>(std::chrono::system_clock::period::num) / \
                                        static_cast<double>(std::chrono::system_clock::period::den);
                        double const seconds = ticks * SECONDS_PER_TICK;
                        return seconds;
    }

    class Scope
    {
      public:
        Scope(
            Timer * const parent) :
          m_parent(parent),
          m_start(now())
        {
          // do nothing
        }

        Scope(
            Scope&& scope) :
          m_parent(scope.m_parent),
          m_start(scope.m_start)
        {
          scope.m_parent = nullptr;
          scope.m_start = 0;
        }

        Scope(
            Scope const & other) = delete;

        Scope& operator=(
            Scope const & other) = delete;

        ~Scope()
        {
          double const stop = now();

          if (m_parent != nullptr) {
            m_parent->add(stop - m_start);
          }
        }

      private:
        Timer * m_parent;
        double m_start;
    };

    Timer() :
      m_duration(0),
      m_scope(nullptr)
                {
      // do nothing
    }

    Scope scope()
    {
      if (m_scope.get() != nullptr) {
        throw std::runtime_error(
            "Cannot start scope for already running timer.");
      }

      return Scope(this);
    }

    void start()
    {
      if (m_scope.get() != nullptr) {
        throw std::runtime_error("Cannot start already running timer.");
      }

      m_scope.reset(new Scope(this));
    }

    void stop()
    {
      if (m_scope.get() == nullptr) {
        throw std::runtime_error("Cannot stop non-running timer.");
      }

      // destroy scope (adding durationg).
      m_scope.reset(nullptr);
    }

    double poll() const
    {
      if (m_scope.get() != nullptr) {
        throw std::runtime_error("Cannot poll running timer.");
      }

      return m_duration;
    }

    void add(
      double duration)
    {
      m_duration += duration;
    }

  private:
    double m_duration;
    std::unique_ptr<Scope> m_scope;
};

}

#endif