time.hpp

// Copyright (C) 2022 Petter Nilsson. MIT License.
 
#pragma once
 
#include <chrono>
#include <concepts>
 
namespace smooth::feedback {
 
template<typename T>
struct time_trait;
 
// clang-format off
 
template<typename T>
concept Time = requires(T t1, T t2, double t_dbl)
{
  {time_trait<T>::plus(t1, t_dbl)}->std::convertible_to<T>;
 
  {time_trait<T>::minus(t2, t1)}->std::convertible_to<double>;
};
 
// clang-format on
 
template<std::floating_point T>
struct time_trait<T>
{
  // \cond
  static constexpr T plus(T t, double t_dbl) { return t + static_cast<T>(t_dbl); }
 
  static constexpr double minus(T t2, T t1) { return static_cast<double>(t2 - t1); }
  // \endcond
};
 
template<typename Clock, typename Duration>
struct time_trait<std::chrono::time_point<Clock, Duration>>
{
  // \cond
  using T = std::chrono::time_point<Clock, Duration>;
 
  static constexpr T plus(T t, double t_dbl)
  {
    return t + std::chrono::duration_cast<Duration>(std::chrono::duration<double>(t_dbl));
  }
 
  static constexpr double minus(T t2, T t1)
  {
    return std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1).count();
  }
  // \endcond
};
 
template<typename Rep, typename Ratio>
struct time_trait<std::chrono::duration<Rep, Ratio>>
{
  // \cond
  using T = std::chrono::duration<Rep, Ratio>;
 
  static constexpr T plus(T t, double t_dbl)
  {
    return t + std::chrono::duration_cast<T>(std::chrono::duration<double>(t_dbl));
  }
 
  static constexpr double minus(T t2, T t1)
  {
    return std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1).count();
  }
  // \endcond
};
 
}  // namespace smooth::feedback