count.hpp

/*
 * This file is part of libtcspc
 * Copyright 2019-2026 Board of Regents of the University of Wisconsin System
 * SPDX-License-Identifier: MIT
 */
 
#pragma once
 
#include "arg_wrappers.hpp"
#include "common.hpp"
#include "context.hpp"
#include "int_types.hpp"
#include "introspect.hpp"
#include "processor.hpp"
 
#include <functional>
#include <stdexcept>
#include <type_traits>
#include <utility>
 
namespace tcspc {
 
namespace internal {
 
template <typename TickEvent, typename FireEvent, typename ResetEvent,
          bool FireAfterTick, typename Downstream>
class count_up_to {
    // Do not require handling of ResetEvent, as it may not be used at all.
    static_assert(processor<Downstream, TickEvent, FireEvent>);
 
    u64 count;
    u64 init;
    u64 thresh;
    u64 lmt;
 
    Downstream downstream;
 
    template <typename Abstime> void pre_tick(Abstime abstime) {
        if constexpr (!FireAfterTick) {
            if (count == thresh)
                downstream.handle(FireEvent{abstime});
        }
    }
 
    template <typename Abstime> void post_tick(Abstime abstime) {
        ++count;
 
        if constexpr (FireAfterTick) {
            if (count == thresh)
                downstream.handle(FireEvent{abstime});
        }
 
        if (count == lmt)
            count = init;
    }
 
  public:
    explicit count_up_to(arg::threshold<u64> threshold, arg::limit<u64> limit,
                         arg::initial_count<u64> initial_count,
                         Downstream downstream)
        : count(initial_count.value), init(initial_count.value),
          thresh(threshold.value), lmt(limit.value),
          downstream(std::move(downstream)) {
        if (init >= lmt)
            throw std::invalid_argument(
                "count_up_to limit must be greater than initial_count");
    }
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "count_up_to");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    void handle(TickEvent const &event) {
        pre_tick(event.abstime);
        downstream.handle(event);
        post_tick(event.abstime);
    }
 
    void handle(TickEvent &&event) {
        auto const abstime = event.abstime;
        pre_tick(abstime);
        downstream.handle(std::move(event));
        post_tick(abstime);
    }
 
    template <typename E>
        requires handler_for<Downstream, std::remove_cvref_t<E>>
    void handle(E &&event) {
        if constexpr (std::is_convertible_v<std::remove_cvref_t<E>,
                                            ResetEvent>) {
            count = init;
        }
        downstream.handle(std::forward<E>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename TickEvent, typename FireEvent, typename ResetEvent,
          bool FireAfterTick, typename Downstream>
auto count_up_to(arg::threshold<u64> threshold, arg::limit<u64> limit,
                 arg::initial_count<u64> initial_count,
                 Downstream downstream) {
    return internal::count_up_to<TickEvent, FireEvent, ResetEvent,
                                 FireAfterTick, Downstream>(
        threshold, limit, initial_count, std::move(downstream));
}

template <typename TickEvent, typename FireEvent, typename ResetEvent,
          bool FireAfterTick, typename Downstream>
auto count_down_to(arg::threshold<u64> threshold, arg::limit<u64> limit,
                   arg::initial_count<u64> initial_count,
                   Downstream downstream) {
    // Alter parameters to emulate count down using count up.
    if (limit.value >= initial_count.value)
        throw std::invalid_argument(
            "count_down_to limit must be less than initial_count");
    if (threshold.value > initial_count.value ||
        threshold.value < limit.value) {
        // Counter will never fire; no change to threshold needed.
    } else {
        // Mirror threshold around midpoint of initial_count and limit.
        threshold.value =
            limit.value + (initial_count.value - threshold.value);
    }
    using std::swap;
    swap(initial_count.value, limit.value);
 
    return internal::count_up_to<TickEvent, FireEvent, ResetEvent,
                                 FireAfterTick, Downstream>(
        threshold, limit, initial_count, std::move(downstream));
}

class count_access {
    std::function<u64()> count_fn;
 
  public:
    template <typename Func>
    explicit count_access(Func count_func) : count_fn(count_func) {}

    auto count() -> u64 { return count_fn(); }
};
 
namespace internal {
 
template <typename Event, typename Downstream> class count {
    static_assert(processor<Downstream, Event>);
 
    u64 ct = 0;
 
    Downstream downstream;
 
    // Cold data after downstream.
    access_tracker<count_access> trk;
 
  public:
    explicit count(access_tracker<count_access> &&tracker,
                   Downstream downstream)
        : downstream(std::move(downstream)), trk(std::move(tracker)) {
        trk.register_access_factory([](auto &tracker) {
            auto *self = LIBTCSPC_OBJECT_FROM_TRACKER(count, trk, tracker);
            return count_access([self] { return self->ct; });
        });
    }
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "count");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename E>
        requires handler_for<Downstream, std::remove_cvref_t<E>>
    void handle(E &&event) {
        if constexpr (std::is_convertible_v<std::remove_cvref_t<E>, Event>)
            ++ct;
        downstream.handle(std::forward<E>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename Event, typename Downstream>
auto count(access_tracker<count_access> &&tracker, Downstream downstream) {
    return internal::count<Event, Downstream>(std::move(tracker),
                                              std::move(downstream));
}
 
} // namespace tcspc