StopWatch.h

Go to the documentation of this file.

#ifndef LARCORE_TESTUTILS_STOPWATCH_H
#define LARCORE_TESTUTILS_STOPWATCH_H

// C/C++ standard libraries
#include <cstdint> // std::intmax_t
#include <chrono>
#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