Timer.h

#pragma once
 
#include <chrono>
#include <cstdint>
#include <ratio>
#include <type_traits>
 
namespace delpi {
 
// Forward declaration. Found later in this file
struct user_clock;

template <typename T>
class TimerBase {
 public:
  using clock = T;
  typedef typename clock::duration duration;
  typedef typename clock::time_point time_point;

  TimerBase();

  void Start();

  void Pause();

  void Resume();

  [[nodiscard]] bool is_running() const;
  [[nodiscard]] duration elapsed() const;
  [[nodiscard]] std::chrono::duration<double>::rep seconds() const;
 
  TimerBase<T> &operator+=(const TimerBase<T> &other);
  TimerBase<T> operator+(const TimerBase<T> &other) const;
 
 protected:
  [[nodiscard]] time_point now() const { return clock::now(); }
 
 private:
  bool running_{false};      
  time_point last_start_{};  
  duration elapsed_{};       
};
 
template <typename T>
TimerBase<T> &TimerBase<T>::operator+=(const TimerBase<T> &other) {
  elapsed_ += other.elapsed();
  return *this;
}
 
template <typename T>
TimerBase<T> TimerBase<T>::operator+(const TimerBase<T> &other) const {
  TimerBase<T> result = *this;
  result += other;
  return result;
}
 
// Use high_resolution clock if it's steady, otherwise use steady_clock.
using chosen_steady_clock = std::conditional_t<std::chrono::high_resolution_clock::is_steady,
                                               std::chrono::high_resolution_clock, std::chrono::steady_clock>;
 
extern template class TimerBase<chosen_steady_clock>;
class Timer : public TimerBase<chosen_steady_clock> {};

struct user_clock {
  typedef uint64_t rep;
  typedef std::micro period;
  typedef std::chrono::duration<rep, period> duration;
  typedef std::chrono::time_point<user_clock> time_point;
  const bool is_steady = false;  // Not sure how this should be interpreted here
  static time_point now();
};
 
extern template class TimerBase<user_clock>;
class UserTimer : public TimerBase<user_clock> {};

class TimerGuard {
 public:
  TimerGuard(Timer *timer, bool enabled, bool start_timer = true);
 
  TimerGuard(const TimerGuard &) = delete;
  TimerGuard(TimerGuard &&) = delete;
  TimerGuard &operator=(const TimerGuard &) = delete;
  TimerGuard &operator=(TimerGuard &&) = delete;

  ~TimerGuard();

  void Pause();

  void Resume();
 
 private:
  Timer *const timer_;         
  const bool enabled_{false};  
};
 
}  // namespace delpi