StopWatch.h

Go to the documentation of this file.

#ifndef LARCORE_TESTUTILS_STOPWATCH_H
#define LARCORE_TESTUTILS_STOPWATCH_H

// C/C++ standard libraries
#include <chrono>
#include <cstdint> // std::intmax_t
#include <ratio>
#include <type_traits> // std::true_type, std::false_type

namespace testing {
  namespace details {
    template <typename Duration>
    struct isDuration;
  } // namespace details

  template <typename DefaultUnit = std::chrono::duration<double>, // seconds (ratio<1>)
            typename Clock = std::chrono::high_resolution_clock>
  class StopWatch {
    static_assert(details::isDuration<DefaultUnit>::value,
                  "DefaultUnit type is not a std::chrono::duration specialization");

  public:
    using Clock_t = Clock;             
    using DefaultUnit_t = DefaultUnit; 

    using ElapsedTime_t = typename DefaultUnit_t::rep;

    StopWatch(bool start = true);

    template <typename Unit>
    StopWatch(Unit prev, bool start = true);


    void restart();

    void resume();

    void stop();

    template <typename Unit = DefaultUnit_t>
    void setPrevious(Unit dur);



    template <typename Unit = DefaultUnit_t>
    ElapsedTime_t elapsed() const;

    template <typename Unit = DefaultUnit_t>
    ElapsedTime_t partial() const;

    template <typename Unit = DefaultUnit_t>
    ElapsedTime_t previous() const;

    bool running() const;


  protected:
    using TimePoint_t = decltype(Clock_t::now()); 

    TimePoint_t lastStart;      
    DefaultUnit_t previousTime; 
    bool isRunning;             

    static TimePoint_t now();

    DefaultUnit_t partialDur() const;

    template <typename>
    struct makeDurationTrait;

    template <typename Unit>
    using makeDuration_t = typename makeDurationTrait<Unit>::type;

    template <typename Unit, typename From>
    static auto durationTo(From const& dur);

  }; // class StopWatch

  using StandardStopWatch = StopWatch<>;

} // namespace testing

//------------------------------------------------------------------------------
namespace testing {
  namespace details {
    template <typename Duration>
    struct isDuration : public std::false_type {};

    template <typename Rep, typename Period>
    struct isDuration<std::chrono::duration<Rep, Period>> : public std::true_type {};

  } // namespace details
} // namespace testing

//------------------------------------------------------------------------------
//--- StopWatch implementartion
//---
//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
testing::StopWatch<DefaultUnit, Clock>::StopWatch(bool start /* = true */)
  : lastStart{start ? now() : TimePoint_t{}}, previousTime{}, isRunning{start}
{}

template <typename DefaultUnit, typename Clock>
template <typename Unit>
testing::StopWatch<DefaultUnit, Clock>::StopWatch(Unit prev, bool start /* = true */)
  : StopWatch(start)
{
  previousTime = prev;
}

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
void testing::StopWatch<DefaultUnit, Clock>::restart()
{
  lastStart = now();
  isRunning = true;
  previousTime = DefaultUnit_t();
} // testing::StopWatch<>::restart()

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
void testing::StopWatch<DefaultUnit, Clock>::resume()
{
  if (running()) return;
  lastStart = now();
  isRunning = true;
} // testing::StopWatch<>::resume()

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
void testing::StopWatch<DefaultUnit, Clock>::stop()
{
  previousTime += partialDur();
  isRunning = false;
} // testing::StopWatch<>::stop()

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
template <typename Unit>
void testing::StopWatch<DefaultUnit, Clock>::setPrevious(Unit dur)
{
  previousTime = std::chrono::duration_cast<DefaultUnit_t>(dur);
} // testing::StopWatch<>::setPrevious()

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
template <typename Unit>
typename testing::StopWatch<DefaultUnit, Clock>::ElapsedTime_t
testing::StopWatch<DefaultUnit, Clock>::elapsed() const
{
  auto const prev = previous<Unit>();
  return running() ? (prev + partial<Unit>()) : prev;
} // testing::StopWatch<>::elapsed()

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
template <typename Unit>
typename testing::StopWatch<DefaultUnit, Clock>::ElapsedTime_t
testing::StopWatch<DefaultUnit, Clock>::partial() const
{
  return running() ? durationTo<Unit>(partialDur()).count() : ElapsedTime_t(0);
} // testing::StopWatch<>::partial()

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
template <typename Unit>
typename testing::StopWatch<DefaultUnit, Clock>::ElapsedTime_t
testing::StopWatch<DefaultUnit, Clock>::previous() const
{
  return durationTo<Unit>(previousTime).count();
} // testing::StopWatch<>::previous()

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
bool testing::StopWatch<DefaultUnit, Clock>::running() const
{
  return isRunning;
}

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
typename testing::StopWatch<DefaultUnit, Clock>::TimePoint_t
testing::StopWatch<DefaultUnit, Clock>::now()
{
  return Clock_t::now();
}

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
typename testing::StopWatch<DefaultUnit, Clock>::DefaultUnit_t
testing::StopWatch<DefaultUnit, Clock>::partialDur() const
{
  return std::chrono::duration_cast<DefaultUnit_t>(now() - lastStart);
} // testing::StopWatch<>::setPrevious()

//------------------------------------------------------------------------------
// Specialisation: on std::chrono::duration (type is that very same)
namespace testing {
  template <typename DefaultUnit, typename Clock>
  template <typename Rep, typename Duration>
  struct StopWatch<DefaultUnit, Clock>::makeDurationTrait<std::chrono::duration<Rep, Duration>> {
    using type = std::chrono::duration<Rep, Duration>;
  }; // StopWatch<>::makeDurationTrait<duration>

  // Specialisation: on std::ratio (type is a duration based on that ratio)
  template <typename DefaultUnit, typename Clock>
  template <std::intmax_t Num, std::intmax_t Den>
  struct StopWatch<DefaultUnit, Clock>::makeDurationTrait<std::ratio<Num, Den>> {
    using type = std::chrono::duration<typename StopWatch<DefaultUnit, Clock>::ElapsedTime_t,
                                       std::ratio<Num, Den>>;
  }; // struct makeDurationTrait<duration>

} // namespace testing

//------------------------------------------------------------------------------
template <typename DefaultUnit, typename Clock>
template <typename Unit, typename From>
auto testing::StopWatch<DefaultUnit, Clock>::durationTo(From const& dur)
{
  return std::chrono::duration_cast<makeDuration_t<Unit>>(dur);
}

//------------------------------------------------------------------------------

#endif // LARCORE_TESTUTILS_STOPWATCH_H