timer.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2022 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************
 * This file is a part of EtcPal. For more information, go to:
 * https://github.com/ETCLabs/EtcPal
 ******************************************************************************/
 
 
#ifndef ETCPAL_CPP_TIMER_H_
#define ETCPAL_CPP_TIMER_H_
 
#include <algorithm>
#include <chrono>
#include <limits>
#include <sstream>
#include <string>
#include "etcpal/timer.h"
#include "etcpal/cpp/common.h"
 
namespace etcpal
{
 
inline std::string DurationToString(int32_t duration_ms) noexcept
{
  std::stringstream res;
 
  std::chrono::milliseconds milliseconds{std::abs(duration_ms)};
 
  auto seconds = std::chrono::duration_cast<std::chrono::seconds>(milliseconds);
  milliseconds -= std::chrono::duration_cast<std::chrono::milliseconds>(seconds);
  auto minutes = std::chrono::duration_cast<std::chrono::minutes>(seconds);
  seconds -= std::chrono::duration_cast<std::chrono::seconds>(minutes);
  auto hours = std::chrono::duration_cast<std::chrono::hours>(minutes);
  minutes -= std::chrono::duration_cast<std::chrono::minutes>(hours);
 
  if (duration_ms < 0)
    res << "-";
  if (hours > std::chrono::hours{0})
    res << hours.count() << " hr ";
  if (minutes > std::chrono::minutes{0})
    res << minutes.count() << " min ";
  if (seconds > std::chrono::seconds{0})
    res << seconds.count() << " sec ";
 
  res << milliseconds.count() << " ms";
 
  return res.str();
}
 
class TimePoint
{
public:
  TimePoint() = default;
  constexpr TimePoint(uint32_t ms);
 
  constexpr uint32_t value() const noexcept;
 
  ETCPAL_CONSTEXPR_14 TimePoint& operator+=(uint32_t duration) noexcept;
  ETCPAL_CONSTEXPR_14 TimePoint& operator-=(uint32_t duration) noexcept;
 
  static TimePoint Now() noexcept;
 
private:
  uint32_t ms_{0};
};
 
constexpr TimePoint::TimePoint(uint32_t ms) : ms_(ms)
{
}
 
constexpr uint32_t TimePoint::value() const noexcept
{
  return ms_;
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE TimePoint& TimePoint::operator+=(uint32_t duration) noexcept
{
  ms_ += duration;
  return *this;
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE TimePoint& TimePoint::operator-=(uint32_t duration) noexcept
{
  ms_ -= duration;
  return *this;
}
 
inline TimePoint TimePoint::Now() noexcept
{
  return etcpal_getms();
}
 
class Timer
{
public:
  Timer() = default;
  // Note: this constructor is not explicit by design, to allow implicit conversions e.g.
  //   etcpal::Timer timer = etcpal_c_function_that_returns_timer();
  constexpr Timer(const EtcPalTimer& c_timer) noexcept;
  Timer& operator=(const EtcPalTimer& c_timer) noexcept;
  explicit Timer(uint32_t interval) noexcept;
  template <typename Rep, typename Period>
  explicit Timer(const std::chrono::duration<Rep, Period>& interval) noexcept;
 
  constexpr const EtcPalTimer&     get() const noexcept;
  ETCPAL_CONSTEXPR_14 EtcPalTimer& get() noexcept;
 
  TimePoint GetStartTime() const noexcept;
  uint32_t  GetInterval() const noexcept;
  uint32_t  GetElapsed() const noexcept;
  uint32_t  GetRemaining() const noexcept;
  bool      IsExpired() const noexcept;
 
  void Start(uint32_t interval) noexcept;
  template <typename Rep, typename Period>
  void Start(const std::chrono::duration<Rep, Period>& interval) noexcept;
  void Reset() noexcept;
 
private:
  EtcPalTimer timer_{};
};
 
constexpr Timer::Timer(const EtcPalTimer& c_timer) noexcept : timer_(c_timer)
{
}
 
inline Timer& Timer::operator=(const EtcPalTimer& c_timer) noexcept
{
  timer_ = c_timer;
  return *this;
}
 
inline Timer::Timer(uint32_t interval) noexcept
{
  Start(interval);
}
 
template <typename Rep, typename Period>
Timer::Timer(const std::chrono::duration<Rep, Period>& interval) noexcept
{
  Start(interval);
}
 
constexpr const EtcPalTimer& Timer::get() const noexcept
{
  return timer_;
}
 
ETCPAL_CONSTEXPR_14_OR_INLINE EtcPalTimer& Timer::get() noexcept
{
  return timer_;
}
 
inline TimePoint Timer::GetStartTime() const noexcept
{
  return timer_.reset_time;
}
 
inline uint32_t Timer::GetInterval() const noexcept
{
  return timer_.interval;
}
 
inline uint32_t Timer::GetElapsed() const noexcept
{
  return etcpal_timer_elapsed(&timer_);
}
 
inline uint32_t Timer::GetRemaining() const noexcept
{
  return etcpal_timer_remaining(&timer_);
}
 
inline bool Timer::IsExpired() const noexcept
{
  return etcpal_timer_is_expired(&timer_);
}
 
inline void Timer::Start(uint32_t interval) noexcept
{
  etcpal_timer_start(&timer_, interval);
}
 
template <typename Rep, typename Period>
void Timer::Start(const std::chrono::duration<Rep, Period>& interval) noexcept
{
  uint32_t interval_clamped = static_cast<uint32_t>(
      std::min(std::chrono::milliseconds(interval).count(),
               static_cast<std::chrono::milliseconds::rep>(std::numeric_limits<uint32_t>::max())));
  etcpal_timer_start(&timer_, interval_clamped);
}
 
inline void Timer::Reset() noexcept
{
  etcpal_timer_reset(&timer_);
}
 
 
constexpr int32_t operator-(const TimePoint& a, const TimePoint& b) noexcept
{
  return static_cast<int32_t>(a.value() - b.value());
}
 
constexpr bool operator==(const TimePoint& a, const TimePoint& b) noexcept
{
  return (a.value() == b.value());
}
 
constexpr bool operator!=(const TimePoint& a, const TimePoint& b) noexcept
{
  return !(a == b);
}
 
constexpr bool operator<(const TimePoint& a, const TimePoint& b) noexcept
{
  return (a - b) < 0;
}
 
constexpr bool operator>(const TimePoint& a, const TimePoint& b) noexcept
{
  return b < a;
}
 
constexpr bool operator<=(const TimePoint& a, const TimePoint& b) noexcept
{
  return !(b < a);
}
 
constexpr bool operator>=(const TimePoint& a, const TimePoint& b) noexcept
{
  return !(a < b);
}
 
 
};  // namespace etcpal
 
#endif  // ETCPAL_CPP_TIMER_H_