libxr_time.hpp

#pragma once
 
#include <cstdint>
 
#include "libxr_assert.hpp"
 
namespace LibXR
{
namespace Detail
{
 
[[nodiscard]] inline uint64_t& TimebaseMaxValidUsStorage() noexcept
{
  static uint64_t value = UINT64_MAX;
  return value;
}
 
[[nodiscard]] inline uint32_t& TimebaseMaxValidMsStorage() noexcept
{
  static uint32_t value = UINT32_MAX;
  return value;
}
 
[[nodiscard]] inline uint64_t TimebaseMaxValidUs() noexcept
{
  return TimebaseMaxValidUsStorage();
}
 
[[nodiscard]] inline uint32_t TimebaseMaxValidMs() noexcept
{
  return TimebaseMaxValidMsStorage();
}
 
inline void ConfigureTimebaseWrapRange(uint64_t max_valid_us,
                                       uint32_t max_valid_ms) noexcept
{
  TimebaseMaxValidUsStorage() = max_valid_us;
  TimebaseMaxValidMsStorage() = max_valid_ms;
}
 
}  // namespace Detail
 
class MicrosecondTimestamp
{
 public:
  MicrosecondTimestamp() = default;
 
  MicrosecondTimestamp(uint64_t microsecond) : microsecond_(microsecond) {}
 
  operator uint64_t() const { return microsecond_; }
 
  class Duration
  {
   public:
    Duration(uint64_t diff) : diff_(diff) {}
 
    operator uint64_t() const { return diff_; }
 
    [[nodiscard]] double ToSecond() const
    {
      return static_cast<double>(diff_) / 1000000.0;
    }
 
    [[nodiscard]] float ToSecondf() const
    {
      return static_cast<float>(diff_) / 1000000.0f;
    }
 
    [[nodiscard]] uint64_t ToMicrosecond() const { return diff_; }
 
    [[nodiscard]] uint32_t ToMillisecond() const { return diff_ / 1000u; }
 
   private:
    uint64_t diff_ = 0;
  };
 
  [[nodiscard]] Duration operator-(const MicrosecondTimestamp& old_timestamp) const
  {
    uint64_t elapsed = 0;
    const uint64_t max_valid = Detail::TimebaseMaxValidUs();
 
    if (microsecond_ >= old_timestamp.microsecond_)
    {
      elapsed = microsecond_ - old_timestamp.microsecond_;
    }
    else
    {
      elapsed = microsecond_ + (max_valid - old_timestamp.microsecond_) + 1ULL;
    }
 
    ASSERT(elapsed <= max_valid);
 
    return Duration(elapsed);
  }
 
  MicrosecondTimestamp& operator=(const MicrosecondTimestamp& other) = default;
 
 private:
  uint64_t microsecond_ = 0;
};
 
class MillisecondTimestamp
{
 public:
  MillisecondTimestamp() = default;
 
  MillisecondTimestamp(uint32_t millisecond) : millisecond_(millisecond) {}
 
  operator uint32_t() const { return millisecond_; }
 
  class Duration
  {
   public:
    Duration(uint32_t diff) : diff_(diff) {}
 
    operator uint32_t() const { return diff_; }
 
    [[nodiscard]] double ToSecond() const
    {
      return static_cast<double>(diff_) / 1000.0;
    }
 
    [[nodiscard]] float ToSecondf() const
    {
      return static_cast<float>(diff_) / 1000.0f;
    }
 
    [[nodiscard]] uint32_t ToMillisecond() const { return diff_; }
 
    [[nodiscard]] uint64_t ToMicrosecond() const
    {
      return static_cast<uint64_t>(diff_) * 1000u;
    }
 
   private:
    uint32_t diff_ = 0;
  };
 
  [[nodiscard]] Duration operator-(const MillisecondTimestamp& old_timestamp) const
  {
    uint32_t elapsed = 0;
    const uint32_t max_valid = Detail::TimebaseMaxValidMs();
 
    if (millisecond_ >= old_timestamp.millisecond_)
    {
      elapsed = millisecond_ - old_timestamp.millisecond_;
    }
    else
    {
      elapsed = millisecond_ + (max_valid - old_timestamp.millisecond_) + 1U;
    }
 
    ASSERT(elapsed <= max_valid);
 
    return Duration(elapsed);
  }
 
 private:
  uint32_t millisecond_ = 0;
};
 
}  // namespace LibXR