libxr_time.hpp

#pragma once
 
#include <cstdint>
 
#include "libxr_assert.hpp"
#include "libxr_def.hpp"
 
inline uint64_t libxr_timebase_max_valid_us = UINT64_MAX;  // NOLINT
 
inline uint32_t libxr_timebase_max_valid_ms = UINT32_MAX;  // NOLINT
 
namespace LibXR
{
 
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;
 
    if (microsecond_ >= old_timestamp.microsecond_)
    {
      elapsed = microsecond_ - old_timestamp.microsecond_;
    }
    else
    {
      elapsed = microsecond_ + (libxr_timebase_max_valid_us - old_timestamp.microsecond_) +
                1ULL;
    }
 
    ASSERT(elapsed <= libxr_timebase_max_valid_us);
 
    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;
 
    if (millisecond_ >= old_timestamp.millisecond_)
    {
      elapsed = millisecond_ - old_timestamp.millisecond_;
    }
    else
    {
      elapsed =
          millisecond_ + (libxr_timebase_max_valid_ms - old_timestamp.millisecond_) + 1U;
    }
 
    ASSERT(elapsed <= libxr_timebase_max_valid_ms);
 
    return Duration(elapsed);
  }
 
 private:
  uint32_t millisecond_ = 0;
};
 
}  // namespace LibXR