timing_misc.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 "data_types.hpp"
#include "errors.hpp"
#include "introspect.hpp"
#include "processor.hpp"
 
#include <cmath>
#include <cstddef>
#include <ostream>
#include <stdexcept>
#include <type_traits>
#include <utility>
 
namespace tcspc {

template <typename DataTypes = default_data_types>
struct periodic_sequence_model_event {
    typename DataTypes::abstime_type abstime;

    double delay;

    double interval;

    friend auto operator==(periodic_sequence_model_event const &lhs,
                           periodic_sequence_model_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &stream,
                           periodic_sequence_model_event const &event)
        -> std::ostream & {
        return stream << "offset_and_interval(" << event.abstime << " + "
                      << event.delay << ", " << event.interval << ')';
    }
};

template <typename DataTypes = default_data_types>
struct real_one_shot_timing_event {
    typename DataTypes::abstime_type abstime;

    double delay;

    friend auto operator==(real_one_shot_timing_event const &lhs,
                           real_one_shot_timing_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &stream,
                           real_one_shot_timing_event const &event)
        -> std::ostream & {
        return stream << "real_one_shot_timing(" << event.abstime << " + "
                      << event.delay << ')';
    }
};

template <typename DataTypes = default_data_types>
struct real_linear_timing_event {
    typename DataTypes::abstime_type abstime;

    double delay;

    double interval;

    std::size_t count;

    friend auto operator==(real_linear_timing_event const &lhs,
                           real_linear_timing_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &stream,
                           real_linear_timing_event const &event)
        -> std::ostream & {
        return stream << "real_linear_timing(" << event.abstime << " + "
                      << event.delay << ", " << event.interval << ", "
                      << event.count << ')';
    }
};
 
namespace internal {
 
template <typename DataTypes, typename Downstream>
class retime_periodic_sequences {
    static_assert(
        processor<Downstream, periodic_sequence_model_event<DataTypes>>);
 
    using abstime_type = typename DataTypes::abstime_type;
 
    abstime_type max_shift;
 
    Downstream downstream;
 
  public:
    explicit retime_periodic_sequences(
        arg::max_time_shift<typename DataTypes::abstime_type> max_time_shift,
        Downstream downstream)
        : max_shift(max_time_shift.value), downstream(std::move(downstream)) {
        if (max_shift < 0)
            throw std::invalid_argument(
                "retime_periodic_sequences max_time_shift must not be negative");
    }
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "retime_periodic_sequences");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename DT>
    void handle(periodic_sequence_model_event<DT> const &event) {
        static_assert(std::is_same_v<typename DT::abstime_type, abstime_type>);
 
        auto delta = std::floor(event.delay) - 1.0;
        if (std::abs(delta) > static_cast<double>(max_shift))
            throw data_validation_error(
                "retime periodic sequence: abstime would shift more than max time shift");
 
        abstime_type abstime{};
        if constexpr (std::is_unsigned_v<abstime_type>) {
            if (delta < 0.0) {
                auto ndelta = static_cast<abstime_type>(-delta);
                if (ndelta > event.abstime)
                    throw data_validation_error(
                        "retime periodic sequence: abstime would be negative but abstime_type is unsigned");
                abstime = event.abstime - ndelta;
            } else {
                abstime = event.abstime + static_cast<abstime_type>(delta);
            }
        } else {
            abstime = event.abstime + static_cast<abstime_type>(delta);
        }
 
        downstream.handle(periodic_sequence_model_event<DataTypes>{
            abstime, event.delay - delta, event.interval});
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename DataTypes = default_data_types, typename Downstream>
auto retime_periodic_sequences(
    arg::max_time_shift<typename DataTypes::abstime_type> max_time_shift,
    Downstream downstream) {
    return internal::retime_periodic_sequences<DataTypes, Downstream>(
        max_time_shift, std::move(downstream));
}
 
namespace internal {
 
template <typename DataTypes, typename Downstream>
class extrapolate_periodic_sequences {
    static_assert(
        processor<Downstream, real_one_shot_timing_event<DataTypes>>);
 
    double m;
    Downstream downstream;
 
  public:
    explicit extrapolate_periodic_sequences(
        arg::tick_index<std::size_t> tick_index, Downstream downstream)
        : m(static_cast<double>(tick_index.value)),
          downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "extrapolate_periodic_sequences");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename DT>
    void handle(periodic_sequence_model_event<DT> const &event) {
        static_assert(std::is_same_v<typename DT::abstime_type,
                                     typename DataTypes::abstime_type>);
        downstream.handle(real_one_shot_timing_event<DataTypes>{
            event.abstime, event.delay + event.interval * m});
    }
 
    template <typename DT>
    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
    void handle(periodic_sequence_model_event<DT> &&event) {
        handle(static_cast<periodic_sequence_model_event<DT> const &>(event));
    }
 
    template <typename OtherEvent>
        requires handler_for<Downstream, std::remove_cvref_t<OtherEvent>>
    void handle(OtherEvent &&event) {
        downstream.handle(std::forward<OtherEvent>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename DataTypes = default_data_types, typename Downstream>
auto extrapolate_periodic_sequences(arg::tick_index<std::size_t> tick_index,
                                    Downstream downstream) {
    return internal::extrapolate_periodic_sequences<DataTypes, Downstream>(
        tick_index, std::move(downstream));
}
 
namespace internal {
 
template <typename DataTypes, typename Downstream>
class add_count_to_periodic_sequences {
    static_assert(processor<Downstream, real_linear_timing_event<DataTypes>>);
 
    std::size_t ct;
    Downstream downstream;
 
  public:
    explicit add_count_to_periodic_sequences(arg::count<std::size_t> count,
                                             Downstream downstream)
        : ct(count.value), downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "add_count_to_periodic_sequences");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename DT>
    void handle(periodic_sequence_model_event<DT> const &event) {
        static_assert(std::is_same_v<typename DT::abstime_type,
                                     typename DataTypes::abstime_type>);
        downstream.handle(real_linear_timing_event<DataTypes>{
            event.abstime, event.delay, event.interval, ct});
    }
 
    template <typename DT>
    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
    void handle(periodic_sequence_model_event<DT> &&event) {
        handle(static_cast<periodic_sequence_model_event<DT> const &>(event));
    }
 
    template <typename OtherEvent>
        requires handler_for<Downstream, std::remove_cvref_t<OtherEvent>>
    void handle(OtherEvent &&event) {
        downstream.handle(std::forward<OtherEvent>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename DataTypes = default_data_types, typename Downstream>
auto add_count_to_periodic_sequences(arg::count<std::size_t> count,
                                     Downstream downstream) {
    return internal::add_count_to_periodic_sequences<DataTypes, Downstream>(
        count, std::move(downstream));
}
 
namespace internal {
 
template <typename TickEvent, typename StartEvent, typename StopEvent,
          typename Downstream>
class convert_sequences_to_start_stop {
    static_assert(processor<Downstream, StartEvent, StopEvent>);
 
    static_assert(
        std::is_same_v<decltype(std::declval<TickEvent>().abstime),
                       decltype(std::declval<StartEvent>().abstime)>);
    static_assert(std::is_same_v<decltype(std::declval<TickEvent>().abstime),
                                 decltype(std::declval<StopEvent>().abstime)>);
 
    std::size_t input_len;
    std::size_t seen = 0;
    Downstream downstream;
 
  public:
    explicit convert_sequences_to_start_stop(arg::count<std::size_t> count,
                                             Downstream downstream)
        : input_len(count.value + 1), downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "convert_sequences_to_start_stop");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    void handle(TickEvent const &event) {
        if (seen > 0) {
            StopEvent e{};
            e.abstime = event.abstime;
            downstream.handle(std::move(e));
        }
        ++seen;
        if (seen < input_len) {
            StartEvent e{};
            e.abstime = event.abstime;
            downstream.handle(std::move(e));
        } else {
            seen = 0;
        }
    }
 
    // NOLINTNEXTLINE(cppcoreguidelines-rvalue-reference-param-not-moved)
    void handle(TickEvent &&event) {
        handle(static_cast<TickEvent const &>(event));
    }
 
    template <typename OtherEvent>
        requires handler_for<Downstream, std::remove_cvref_t<OtherEvent>>
    void handle(OtherEvent &&event) {
        downstream.handle(std::forward<OtherEvent>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename TickEvent, typename StartEvent, typename StopEvent,
          typename Downstream>
auto convert_sequences_to_start_stop(arg::count<std::size_t> count,
                                     Downstream downstream) {
    return internal::convert_sequences_to_start_stop<TickEvent, StartEvent,
                                                     StopEvent, Downstream>(
        count, std::move(downstream));
}
 
} // namespace tcspc