chrono_ticks.h

Go to the documentation of this file.

// Copyright (c) 2026 Tinverse LLC. All rights reserved.
// SPDX-License-Identifier: LicenseRef-Tinverse-Commercial
 
 
#pragma once
 
#include <chrono>
#include <cstdint>
#include <limits>
 
#include "tsm/runtime/coroutine.h"
#include "tsm/ticks.h"
 
namespace tsm::chrono_ticks {
 
template<typename Duration, typename TickPeriod>
[[nodiscard]] constexpr tsm::tick_rep
duration_to_ticks(Duration duration, TickPeriod tick_period)
{
    if (tick_period <= TickPeriod::zero()) {
        return tick_rep{};
    }
    if (duration <= Duration::zero()) {
        return tick_rep{};
    }
 
    const auto whole = duration / tick_period;
    const auto remainder = duration % tick_period;
    const auto elapsed_ticks = whole + (remainder.count() == 0 ? 0 : 1);
    constexpr auto max_ticks = static_cast<decltype(elapsed_ticks)>(
      std::numeric_limits<tsm::tick_rep>::max());
    if (elapsed_ticks >= max_ticks) {
        return std::numeric_limits<tsm::tick_rep>::max();
    }
    return static_cast<tsm::tick_rep>(elapsed_ticks);
}
 
template<typename TickPeriod>
class tick_domain
{
  public:
    using tick_period = TickPeriod;
 
    explicit constexpr tick_domain(TickPeriod period = TickPeriod{ 1 })
      : period_(period)
    {
    }
 
    template<typename Duration>
    [[nodiscard]] constexpr tsm::tick_count to_ticks(
      Duration duration) const noexcept
    {
        return tsm::ticks(duration_to_ticks(duration, period_));
    }
 
    [[nodiscard]] constexpr TickPeriod period() const noexcept
    {
        return period_;
    }
 
  private:
    TickPeriod period_;
};
 
using millisecond_domain = tick_domain<std::chrono::milliseconds>;
using second_domain = tick_domain<std::chrono::seconds>;
 
[[nodiscard]] constexpr millisecond_domain
one_tick_per_millisecond() noexcept
{
    return millisecond_domain{ std::chrono::milliseconds{ 1 } };
}
 
[[nodiscard]] constexpr second_domain
one_tick_per_second() noexcept
{
    return second_domain{ std::chrono::seconds{ 1 } };
}
 
template<typename TickPeriod, typename Duration>
[[nodiscard]] tsm::sleep_ticks_awaitable
sleep_for(tick_domain<TickPeriod> domain, Duration duration) noexcept
{
    return tsm::sleep_ticks(domain.to_ticks(duration));
}
 
template<typename TickPeriod, typename Duration>
[[nodiscard]] tsm::sleep_ticks_awaitable
after(tick_domain<TickPeriod> domain, Duration duration) noexcept
{
    return sleep_for(domain, duration);
}
 
template<typename TickPeriod, typename Duration>
[[nodiscard]] tsm::timeout_ticks_awaitable
timeout(tick_domain<TickPeriod> domain, Duration duration) noexcept
{
    return tsm::timeout_ticks(domain.to_ticks(duration));
}
 
template<typename TickPeriod, typename Duration>
[[nodiscard]] tsm::periodic_ticks
every(tick_domain<TickPeriod> domain, Duration duration) noexcept
{
    return tsm::periodic_ticks{ domain.to_ticks(duration) };
}
 
template<typename Clock, typename TickPeriod>
class elapsed_tick_source
{
  public:
    using clock_type = Clock;
    using tick_period = TickPeriod;
    using time_point = typename Clock::time_point;
 
    explicit elapsed_tick_source(TickPeriod period)
      : period_(period)
      , origin_(Clock::now())
      , last_(origin_)
    {
    }
 
    explicit elapsed_tick_source(tick_domain<TickPeriod> domain)
      : elapsed_tick_source(domain.period())
    {
    }
 
    [[nodiscard]] tsm::tick_rep ticks() const
    {
        return duration_to_ticks(Clock::now() - origin_, period_);
    }
 
    [[nodiscard]] tsm::tick_rep poll()
    {
        const auto now = Clock::now();
        const auto elapsed = duration_to_ticks(now - last_, period_);
        if (elapsed != 0U) {
            last_ += period_ * elapsed;
        }
        return elapsed;
    }
 
    void reset()
    {
        origin_ = Clock::now();
        last_ = origin_;
    }
 
  private:
    TickPeriod period_;
    time_point origin_;
    time_point last_;
};
 
} // namespace tsm::chrono_ticks