timers.hpp

// Copyright 2025 Kevin Exton
//
// 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.
#pragma once
#ifndef CPPNET_TIMERS_HPP
#define CPPNET_TIMERS_HPP
#include "interrupt.hpp"
#include "net/detail/concepts.hpp"
 
#include <chrono>
#include <functional>
#include <queue>
#include <stack>
namespace net::timers {
 
using timer_id = std::size_t;
static constexpr timer_id INVALID_TIMER = -1;
using handler_t = std::function<void(timer_id)>;
using clock = std::chrono::steady_clock;
using timestamp = std::chrono::time_point<clock>;
using duration = std::chrono::microseconds;
 
namespace detail {
struct event {
  handler_t handler;
  timer_id id = INVALID_TIMER;
  timestamp start;
  duration period{};
  std::atomic_flag armed;
};
 
struct event_ref {
  timestamp expires_at;
  timer_id id = INVALID_TIMER;
};
 
inline auto operator<=>(const event_ref &lhs,
                        const event_ref &rhs) -> std::strong_ordering;
inline auto operator==(const event_ref &lhs, const event_ref &rhs) -> bool;
} // namespace detail.
 
template <InterruptSource Interrupt>
class timers : public interrupt<Interrupt> {
public:
  using interrupt_type = interrupt<Interrupt>;
 
  timers() = default;
  timers(const timers &other) = delete;
  timers(timers &&other) noexcept;
 
  auto operator=(const timers &other) = delete;
  auto operator=(timers &&other) noexcept -> timers &;
 
  template <InterruptSource I>
  friend auto swap(timers<I> &lhs, timers<I> &rhs) noexcept -> void;
 
  auto add(timestamp when, handler_t handler,
           duration period = duration::zero()) -> timer_id;
 
  template <class Rep, class Period>
  auto add(std::chrono::duration<Rep, Period> when, handler_t handler,
           duration period = duration::zero()) -> timer_id;
 
  auto add(std::uint64_t when, handler_t handler,
           std::uint64_t period = 0) -> timer_id;
 
  auto remove(timer_id tid) noexcept -> timer_id;
 
  auto resolve() -> duration;
 
  ~timers() = default;
 
private:
  template <typename T>
  using minheap = std::priority_queue<T, std::vector<T>, std::greater<>>;
 
  struct {
    std::deque<detail::event> events;
    minheap<detail::event_ref> eventq;
    std::stack<timer_id> free_ids;
  } state_;
 
  mutable std::mutex mtx_;
};
 
} // namespace net::timers
 
#include "impl/timers_impl.hpp" // IWYU pragma: export
 
#endif // CPPNET_TIMERS_HPP