time.h

Go to the documentation of this file.

// Copyright (c) Space-ng, inc. All rights reserved.
#pragma once
#include "sol3/core/host_identity.h"
#include "sol3/core/msg/stamp.h"
#include "sol3/log/except.h"
 
#include <chrono>
 
namespace sol3::core {
inline msg::TimePoint timePoint(
    std::chrono::system_clock::time_point const& time_point) {
  msg::TimePoint out;
  out.mutate_clock(msg::ClockType_WALL_UTC);
  out.mutate_ns(time_point.time_since_epoch().count());
  return out;
}
 
inline msg::TimePoint timePoint(
    std::chrono::steady_clock::time_point const& time_point) {
  msg::TimePoint out;
  out.mutate_clock(msg::ClockType_MONOTONIC);
  out.mutate_ns(time_point.time_since_epoch().count());
  return out;
}
 
inline std::chrono::system_clock::time_point toChronoSystemClock(
    msg::TimePoint time_point) {
  SOL3_EXPECT(
      time_point.clock() == msg::ClockType_WALL_UTC,
      "Wrong clock type {}",
      msg::EnumNameClockType(time_point.clock()));
  return std::chrono::system_clock::time_point() +
         std::chrono::nanoseconds(time_point.ns());
}
 
template <typename TClock = std::chrono::system_clock>
inline msg::Stamp stampFrom(
    typename TClock::time_point const& time_point,
    msg::StampType stamp_type,
    uint16_t host_id = hostIdentity().host_id_numeric) {
  return msg::Stamp(timePoint(time_point), stamp_type, host_id);
}
 
template <typename TClock = std::chrono::system_clock>
inline msg::Stamp stampNow(
    msg::StampType stamp_type,
    uint16_t host_id = hostIdentity().host_id_numeric) {
  msg::Stamp stamp;
  return stampFrom<TClock>(TClock::now(), stamp_type, host_id);
}
 
template <typename TClock = std::chrono::system_clock>
inline msg::Stamp sendStampNow(
    uint16_t host_id = hostIdentity().host_id_numeric) {
  return stampNow<TClock>(msg::StampType_SEND, host_id);
}
 
template <typename TClock = std::chrono::system_clock>
inline msg::Stamp recvStampNow(
    uint16_t host_id = hostIdentity().host_id_numeric) {
  return stampNow<TClock>(msg::StampType_RECV, host_id);
}
 
template <typename TClock = std::chrono::system_clock>
inline msg::Stamp measurementStampFrom(
    typename TClock::time_point time_point,
    uint16_t host_id = hostIdentity().host_id_numeric) {
  return stampFrom<TClock>(time_point, msg::StampType_MEASUREMENT, host_id);
}
 
inline std::chrono::nanoseconds toDuration(double seconds) {
  return std::chrono::duration_cast<std::chrono::nanoseconds>(
      std::chrono::duration<double>(seconds));
}
 
template <typename TRep, typename TPeriod>
double toSeconds(std::chrono::duration<TRep, TPeriod> const& duration) {
  return std::chrono::duration_cast<std::chrono::duration<double>>(duration)
      .count();
}
 
template <typename TClock>
double toSeconds(std::chrono::time_point<TClock> const& time_point) {
  return toSeconds(time_point.time_since_epoch());
}
 
template <class TClock = std::chrono::steady_clock>
class Periodic {
 public:
  using TimePoint = typename TClock::time_point;
  using Duration = typename TClock::duration;
 
  explicit Periodic(Duration period, TimePoint anchor = {})
      : period_(period), anchor_(anchor), deadline_(Duration::zero()) {
    assert(period_ > Duration::zero());
  }
 
  bool due(TimePoint now) {
    if (now < deadline_) {
      return false;
    }
    deadline_ = nextDeadline(now);
    return true;
  }
 
  TimePoint nextDeadline(TimePoint now) const {
    if (now < anchor_) {
      return anchor_;
    }
 
    return anchor_ + ((now - anchor_) / period_ + 1) * period_;
  }
 
 private:
  Duration period_;
  TimePoint anchor_;
  TimePoint deadline_;
};
 
template <class TP0, class... TPn>
constexpr TP0 minTimePoint(const TP0& first, TPn const&... rest) {
  return (std::min)({first, rest...});
}
 
}  // namespace sol3::core