chrono.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2015 Hamburg University of Applied Sciences (HAW)
 *
 * This file is subject to the terms and conditions of the GNU Lesser
 * General Public License v2.1. See the file LICENSE in the top level
 * directory for more details.
 */
 
#ifndef RIOT_CHRONO_HPP
#define RIOT_CHRONO_HPP
 
#include <chrono>
#include <algorithm>
 
#include "time.h"
#include "timex.h"
#include "ztimer64.h"
 
namespace riot {
 
class time_point {
  using native_handle_type = timex_t;
 
 public:
  inline time_point() : m_handle{0, 0} {}
  explicit inline time_point(timex_t&& tp) : m_handle(tp) {}
  constexpr time_point(const time_point& tp) = default;
  constexpr time_point(time_point&& tp) = default;
 
  inline native_handle_type native_handle() const { return m_handle; }
 
  template <class Rep, class Period>
  inline time_point& operator+=(const std::chrono::duration<Rep, Period>& d) {
    auto s = std::chrono::duration_cast<std::chrono::seconds>(d);
    auto m = (std::chrono::duration_cast<std::chrono::microseconds>(d) - s);
    m_handle.seconds += s.count();
    m_handle.microseconds += m.count();
    adjust_overhead();
    return *this;
  }
 
  inline uint32_t seconds() const { return m_handle.seconds; }
 
  inline uint32_t microseconds() const { return m_handle.microseconds; }
 
 private:
  timex_t m_handle;
  void inline adjust_overhead() {
    auto secs = m_handle.microseconds / US_PER_SEC;
    m_handle.seconds += secs;
    m_handle.microseconds -= (secs * US_PER_SEC);
  }
};
 
inline time_point now() {
  timex_t tp;
  tp = timex_from_uint64(ztimer64_now(ZTIMER64_USEC));
  return time_point(std::move(tp));
}
 
inline bool operator<(const time_point& lhs, const time_point& rhs) {
  return lhs.seconds() < rhs.seconds()
         || (lhs.seconds() == rhs.seconds() && lhs.microseconds()
                                               < rhs.microseconds());
}
 
inline bool operator>(const time_point& lhs, const time_point& rhs) {
  return rhs < lhs;
}
 
inline bool operator<=(const time_point& lhs, const time_point& rhs) {
  return !(rhs < lhs);
}
 
inline bool operator>=(const time_point& lhs, const time_point& rhs) {
  return !(lhs < rhs);
}
 
} // namespace riot
 
#endif // RIOT_CHRONO_HPP