check.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 "common.hpp"
#include "core.hpp"
#include "data_types.hpp"
#include "event.hpp"
#include "introspect.hpp"
#include "processor.hpp"
 
#include <limits>
#include <ostream>
#include <sstream>
#include <type_traits>
#include <utility>
 
namespace tcspc {
 
namespace internal {
 
template <typename DataTypes, bool RequireStrictlyIncreasing,
          typename Downstream>
class check_monotonic {
    static_assert(processor<Downstream, warning_event>);
 
    typename DataTypes::abstime_type last_seen =
        std::numeric_limits<typename DataTypes::abstime_type>::min();
 
    Downstream downstream;
 
    LIBTCSPC_NOINLINE void
    issue_warning(typename DataTypes::abstime_type abstime) {
        std::ostringstream stream;
        stream << "non-monotonic abstime: " << last_seen << " followed by "
               << abstime;
        downstream.handle(warning_event{stream.str()});
    }
 
  public:
    explicit check_monotonic(Downstream downstream)
        : downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "check_monotonic");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename Event>
        requires handler_for<Downstream, std::remove_cvref_t<Event>>
    void handle(Event &&event) {
        if constexpr (abstime_stamped<std::remove_cvref_t<Event>>) {
            static_assert(std::is_same_v<decltype(event.abstime),
                                         typename DataTypes::abstime_type>);
            bool const monotonic = RequireStrictlyIncreasing
                                       ? event.abstime > last_seen
                                       : event.abstime >= last_seen;
            if (not monotonic)
                issue_warning(event.abstime);
            last_seen = event.abstime;
        }
        downstream.handle(std::forward<Event>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename DataTypes = default_data_types,
          bool RequireStrictlyIncreasing = false, typename Downstream>
auto check_monotonic(Downstream downstream) {
    return internal::check_monotonic<DataTypes, RequireStrictlyIncreasing,
                                     Downstream>(std::move(downstream));
}
 
namespace internal {
 
template <typename Event0, typename Event1, typename Downstream>
class check_alternating {
    static_assert(processor<Downstream, Event0, Event1, warning_event>);
 
    bool last_saw_0 = false;
    Downstream downstream;
 
    LIBTCSPC_NOINLINE void issue_warning() {
        downstream.handle(warning_event{"non-alternating events"});
    }
 
  public:
    explicit check_alternating(Downstream downstream)
        : downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "check_alternating");
    }
 
    [[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>, Event0>) {
            if (last_saw_0)
                issue_warning();
            last_saw_0 = true;
        } else if constexpr (std::is_convertible_v<std::remove_cvref_t<E>,
                                                   Event1>) {
            if (not last_saw_0)
                issue_warning();
            last_saw_0 = false;
        }
        downstream.handle(std::forward<E>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename Event0, typename Event1, typename Downstream>
auto check_alternating(Downstream downstream) {
    return internal::check_alternating<Event0, Event1, Downstream>(
        std::move(downstream));
}
 
} // namespace tcspc