DeadlineTimer.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: MIT
#pragma once
#ifndef TIME_SHIELD_HEADER_TIMERS_DEADLINETIMER_HPP_INCLUDED
#define TIME_SHIELD_HEADER_TIMERS_DEADLINETIMER_HPP_INCLUDED
 
 
#include <time_shield/core.hpp>
 
#include <chrono>
 
namespace time_shield {
 
    class DeadlineTimer {
    public:
        using clock = std::chrono::steady_clock;
        using duration = clock::duration;
        using time_point = clock::time_point;
 
        DeadlineTimer() noexcept = default;
 
        explicit DeadlineTimer(time_point deadline) noexcept {
            start(deadline);
        }
 
        template<class Rep, class Period>
        explicit DeadlineTimer(std::chrono::duration<Rep, Period> timeout) noexcept {
            start(timeout);
        }
 
        explicit DeadlineTimer(ts_ms_t timeout_ms) noexcept {
            start_ms(timeout_ms);
        }
 
        static DeadlineTimer from_timeout(duration timeout) noexcept {
            DeadlineTimer timer;
            timer.start(timeout);
            return timer;
        }
 
        template<class Rep, class Period>
        static DeadlineTimer from_timeout(std::chrono::duration<Rep, Period> timeout) noexcept {
            DeadlineTimer timer;
            timer.start(timeout);
            return timer;
        }
 
        static DeadlineTimer from_timeout_sec(ts_t timeout_sec) noexcept {
            DeadlineTimer timer;
            timer.start_sec(timeout_sec);
            return timer;
        }
 
        static DeadlineTimer from_timeout_ms(ts_ms_t timeout_ms) noexcept {
            DeadlineTimer timer;
            timer.start_ms(timeout_ms);
            return timer;
        }
 
        void start(time_point deadline) noexcept {
            m_deadline = deadline;
            m_is_running = true;
        }
 
        template<class Rep, class Period>
        void start(std::chrono::duration<Rep, Period> timeout) noexcept {
            const time_point now = clock::now();
            if (timeout <= decltype(timeout)::zero()) {
                start(now);
                return;
            }
 
            duration safe_duration = std::chrono::duration_cast<duration>(timeout);
            if (safe_duration <= duration::zero()) {
                safe_duration = duration(1);
            }
 
            const time_point max_time = (time_point::max)();
            const duration max_offset = max_time - now;
            if (safe_duration >= max_offset) {
                start(max_time);
                return;
            }
 
            start(now + safe_duration);
        }
 
        void start_sec(ts_t timeout_sec) noexcept {
            start(std::chrono::seconds(timeout_sec));
        }
 
        void start_ms(ts_ms_t timeout_ms) noexcept {
            start(std::chrono::milliseconds(timeout_ms));
        }
 
        void stop() noexcept {
            m_is_running = false;
            m_deadline = time_point{};
        }
 
        void set_forever() noexcept {
            m_is_running = true;
            m_deadline = (time_point::max)();
        }
 
        TIME_SHIELD_NODISCARD bool is_running() const noexcept {
            return m_is_running;
        }
 
        TIME_SHIELD_NODISCARD bool is_forever() const noexcept {
            return m_is_running && m_deadline == (time_point::max)();
        }
 
        TIME_SHIELD_NODISCARD time_point deadline() const noexcept {
            return m_deadline;
        }
 
        TIME_SHIELD_NODISCARD ts_ms_t deadline_ms() const noexcept {
            return std::chrono::duration_cast<std::chrono::milliseconds>(m_deadline.time_since_epoch()).count();
        }
 
        TIME_SHIELD_NODISCARD ts_t deadline_sec() const noexcept {
            return std::chrono::duration_cast<std::chrono::seconds>(m_deadline.time_since_epoch()).count();
        }
 
        TIME_SHIELD_NODISCARD bool has_expired() const noexcept {
            return has_expired(clock::now());
        }
 
        TIME_SHIELD_NODISCARD bool has_expired_ms(ts_ms_t now_ms) const noexcept {
            const duration since_epoch = std::chrono::duration_cast<duration>(std::chrono::milliseconds(now_ms));
            return has_expired(time_point(since_epoch));
        }
 
        TIME_SHIELD_NODISCARD bool has_expired_sec(ts_t now_sec) const noexcept {
            const duration since_epoch = std::chrono::duration_cast<duration>(std::chrono::seconds(now_sec));
            return has_expired(time_point(since_epoch));
        }
 
        TIME_SHIELD_NODISCARD bool has_expired(time_point now) const noexcept {
            return m_is_running && now >= m_deadline;
        }
 
        TIME_SHIELD_NODISCARD duration remaining_time() const noexcept {
            return remaining_time(clock::now());
        }
 
        TIME_SHIELD_NODISCARD ts_ms_t remaining_time_ms() const noexcept {
            return std::chrono::duration_cast<std::chrono::milliseconds>(remaining_time()).count();
        }
 
        TIME_SHIELD_NODISCARD ts_t remaining_time_sec() const noexcept {
            return std::chrono::duration_cast<std::chrono::seconds>(remaining_time()).count();
        }
 
        TIME_SHIELD_NODISCARD duration remaining_time(time_point now) const noexcept {
            if (!m_is_running || now >= m_deadline) {
                return duration::zero();
            }
            return m_deadline - now;
        }
 
        void add(duration extend_by) noexcept {
            if (!m_is_running || extend_by <= duration::zero()) {
                return;
            }
 
            const time_point now = clock::now();
            const time_point base = m_deadline > now ? m_deadline : now;
            const duration max_offset = (time_point::max)() - base;
            const duration safe_offset = extend_by < max_offset ? extend_by : max_offset;
            m_deadline = base + safe_offset;
        }
 
        void add_sec(ts_t extend_by_sec) noexcept {
            if (extend_by_sec <= 0) {
                return;
            }
            add(std::chrono::seconds(extend_by_sec));
        }
 
        void add_ms(ts_ms_t extend_by_ms) noexcept {
            if (extend_by_ms <= 0) {
                return;
            }
            add(std::chrono::milliseconds(extend_by_ms));
        }
 
    private:
        time_point m_deadline{};
        bool m_is_running{false};
    };
 
} // namespace time_shield
 
#endif // TIME_SHIELD_HEADER_TIMERS_DEADLINETIMER_HPP_INCLUDED