generate.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 "introspect.hpp"
#include "numeric_traits.hpp"
#include "processor.hpp"
 
#include <concepts>
#include <cstddef>
#include <optional>
#include <stdexcept>
#include <type_traits>
#include <utility>
 
namespace tcspc {

template <typename T, typename TriggerEvent>
concept timing_generator_for =
    std::move_constructible<T> &&
    requires(T &g, T const &cg, TriggerEvent const &event) {
        { g.trigger(event) } -> std::same_as<void>;
        {
            cg.peek()
        } -> std::same_as<
            std::optional<decltype(std::declval<TriggerEvent>().abstime)>>;
        { g.pop() } -> std::same_as<void>;
    };
 
namespace internal {
 
template <typename TriggerEvent, typename OutputEvent,
          typename TimingGenerator, typename Downstream>
    requires timing_generator_for<TimingGenerator, TriggerEvent> &&
             processor<Downstream, TriggerEvent, OutputEvent>
class generate {
    using abstime_type = decltype(std::declval<TriggerEvent>().abstime);
    static_assert(std::is_same_v<decltype(std::declval<OutputEvent>().abstime),
                                 abstime_type>);
 
    TimingGenerator generator;
 
    Downstream downstream;
 
    // Pred: bool(abstime_type const &)
    template <typename Pred> void emit(Pred predicate) {
        auto const &const_gen = generator; // Enforce peek() const.
        for (std::optional<abstime_type> t = const_gen.peek();
             t && predicate(*t); t = const_gen.peek()) {
            OutputEvent event;
            event.abstime = *t;
            generator.pop();
            downstream.handle(std::move(event));
        }
    }
 
  public:
    explicit generate(TimingGenerator generator, Downstream downstream)
        : generator(std::move(generator)), downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "generate");
    }
 
    [[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) {
        emit([now = event.abstime](auto t) { return t <= now; });
        if constexpr (std::is_convertible_v<std::remove_cvref_t<E>,
                                            TriggerEvent>) {
            generator.trigger(event);
        }
        downstream.handle(std::forward<E>(event));
    }
 
    void flush() {
        // Note that we do _not_ generate the remaining timings. Usually timing
        // events beyond the end of the event stream are not useful, and not
        // generating them means that infinite generators can be used.
        downstream.flush();
    }
};
 
} // namespace internal

template <typename TriggerEvent, typename OutputEvent,
          typename TimingGenerator, typename Downstream>
auto generate(TimingGenerator generator, Downstream downstream) {
    return internal::generate<TriggerEvent, OutputEvent, TimingGenerator,
                              Downstream>(std::move(generator),
                                          std::move(downstream));
}

template <typename NumericTraits = default_numeric_traits>
class null_timing_generator {
  public:
    template <typename TriggerEvent> void trigger(TriggerEvent const &event) {
        static_assert(std::is_same_v<decltype(event.abstime),
                                     typename NumericTraits::abstime_type>);
    }

    [[nodiscard]] auto peek() const
        -> std::optional<typename NumericTraits::abstime_type> {
        return std::nullopt;
    }

    void pop() { internal::unreachable(); }
};

template <typename NumericTraits = default_numeric_traits>
class one_shot_timing_generator {
    std::optional<typename NumericTraits::abstime_type> next;
    NumericTraits::abstime_type dly;
 
  public:
    explicit one_shot_timing_generator(
        arg::delay<typename NumericTraits::abstime_type> delay)
        : dly(delay.value) {
        if (dly < 0)
            throw std::invalid_argument(
                "one_shot_timing_generator delay must not be negative");
    }

    template <typename TriggerEvent> void trigger(TriggerEvent const &event) {
        static_assert(std::is_same_v<decltype(event.abstime),
                                     typename NumericTraits::abstime_type>);
        next = event.abstime + dly;
    }

    [[nodiscard]] auto peek() const
        -> std::optional<typename NumericTraits::abstime_type> {
        return next;
    }

    void pop() { next.reset(); }
};

template <typename NumericTraits = default_numeric_traits>
class dynamic_one_shot_timing_generator {
    std::optional<typename NumericTraits::abstime_type> next;
 
  public:
    template <typename TriggerEvent> void trigger(TriggerEvent const &event) {
        static_assert(std::is_same_v<decltype(event.abstime),
                                     typename NumericTraits::abstime_type>);
        static_assert(std::is_same_v<decltype(event.delay),
                                     typename NumericTraits::abstime_type>);
        next = event.abstime + event.delay;
    }

    [[nodiscard]] auto peek() const
        -> std::optional<typename NumericTraits::abstime_type> {
        return next;
    }

    void pop() { next.reset(); }
};

template <typename NumericTraits = default_numeric_traits>
class linear_timing_generator {
    NumericTraits::abstime_type next = 0;
    std::size_t remaining = 0;
 
    NumericTraits::abstime_type dly;
    NumericTraits::abstime_type intval;
    std::size_t ct;
 
  public:
    explicit linear_timing_generator(
        arg::delay<typename NumericTraits::abstime_type> delay,
        arg::interval<typename NumericTraits::abstime_type> interval,
        arg::count<std::size_t> count)
        : dly(delay.value), intval(interval.value), ct(count.value) {
        if (dly < 0)
            throw std::invalid_argument(
                "linear_timing_generator delay must not be negative");
        if (intval <= 0)
            throw std::invalid_argument(
                "linear_timing_generator interval must be positive");
    }

    template <typename TriggerEvent> void trigger(TriggerEvent const &event) {
        static_assert(std::is_same_v<decltype(event.abstime),
                                     typename NumericTraits::abstime_type>);
        next = event.abstime + dly;
        remaining = ct;
    }

    [[nodiscard]] auto peek() const
        -> std::optional<typename NumericTraits::abstime_type> {
        if (remaining > 0)
            return next;
        return std::nullopt;
    }

    void pop() {
        next += intval;
        --remaining;
    }
};

template <typename NumericTraits = default_numeric_traits>
class dynamic_linear_timing_generator {
    NumericTraits::abstime_type next = 0;
    std::size_t remaining = 0;
    NumericTraits::abstime_type interval = 0;
 
  public:
    template <typename TriggerEvent> void trigger(TriggerEvent const &event) {
        static_assert(std::is_same_v<decltype(event.abstime),
                                     typename NumericTraits::abstime_type>);
        next = event.abstime + event.delay;
        remaining = event.count;
        interval = event.interval;
    }

    [[nodiscard]] auto peek() const
        -> std::optional<typename NumericTraits::abstime_type> {
        if (remaining > 0)
            return next;
        return std::nullopt;
    }

    void pop() {
        next += interval;
        --remaining;
    }
};
 
} // namespace tcspc