libxr_time.hpp

#pragma once
 
#include <cstdint>
 
#include "libxr_assert.hpp"
#include "libxr_def.hpp"
 
static inline uint64_t libxr_timebase_max_valid_us = UINT64_MAX;  // NOLINT
static inline uint32_t libxr_timebase_max_valid_ms = UINT32_MAX;  // NOLINT
 
namespace LibXR
{
 
class TimestampUS
{
 public:
  TimestampUS() : microsecond_(0) {}
 
  TimestampUS(uint64_t microsecond) : microsecond_(microsecond) {}
 
  operator uint64_t() const { return microsecond_; }
 
  class TimeDiffUS
  {
   public:
    TimeDiffUS(uint64_t diff) : diff_(diff) {}
 
    operator uint64_t() const { return diff_; }
 
    double to_second() const { return static_cast<double>(diff_) / 1000000.0; }
 
    float to_secondf() const { return static_cast<float>(diff_) / 1000000.0f; }
 
    uint64_t to_microsecond() const { return diff_; }
 
    uint32_t to_millisecond() const { return diff_ / 1000u; }
 
   private:
    uint64_t diff_;  
  };
 
  TimeDiffUS operator-(const TimestampUS &old_microsecond) const
  {
    uint64_t diff;  // NOLINT
 
    if (microsecond_ >= old_microsecond.microsecond_)
    {
      diff = microsecond_ - old_microsecond.microsecond_;
    }
    else
    {
      diff = microsecond_ + (libxr_timebase_max_valid_us - old_microsecond.microsecond_);
    }
 
    ASSERT(diff <= libxr_timebase_max_valid_us);
 
    return TimeDiffUS(diff);
  }
 
  TimestampUS &operator=(const TimestampUS &other)
  {
    if (this != &other)
    {
      microsecond_ = other.microsecond_;
    }
    return *this;
  }
 
 private:
  uint64_t microsecond_;  
};
 
class TimestampMS
{
 public:
  TimestampMS() : millisecond_(0) {}
  TimestampMS(uint32_t millisecond) : millisecond_(millisecond) {}
  operator uint32_t() const { return millisecond_; }
 
  class TimeDiffMS
  {
   public:
    TimeDiffMS(uint32_t diff) : diff_(diff) {}
 
    operator uint32_t() const { return diff_; }
 
    double to_second() { return static_cast<double>(diff_) / 1000.0; }
 
    float to_secondf() { return static_cast<float>(diff_) / 1000.0f; }
 
    uint32_t to_millisecond() const { return diff_; }
 
    uint64_t to_microsecond() const { return diff_ * 1000u; }
 
   private:
    uint32_t diff_;  
  };
 
  TimeDiffMS operator-(TimestampMS &old_millisecond)
  {
    uint32_t diff;  // NOLINT
 
    if (millisecond_ >= old_millisecond.millisecond_)
    {
      diff = millisecond_ - old_millisecond.millisecond_;
    }
    else
    {
      diff = millisecond_ + (libxr_timebase_max_valid_ms - old_millisecond.millisecond_);
    }
 
    ASSERT(diff <= libxr_timebase_max_valid_ms);
 
    return TimeDiffMS(diff);
  }
 
 private:
  uint32_t millisecond_;  
};
 
}  // namespace LibXR