match.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 <type_traits>
#include <utility>
 
namespace tcspc {

template <typename T, typename Event>
concept matcher_for =
    std::move_constructible<T> && requires(T const &m, Event const &e) {
        { m(e) } -> std::same_as<bool>;
    };
 
namespace internal {
 
template <typename Event, typename OutEvent, typename Matcher,
          bool PassMatched, typename Downstream>
    requires matcher_for<Matcher, Event> &&
             processor<Downstream, Event, OutEvent>
class match {
    Matcher matcher;
    Downstream downstream;
 
  public:
    explicit match(Matcher matcher, Downstream downstream)
        : matcher(std::move(matcher)), downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "match");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename E>
        requires(std::convertible_to<std::remove_cvref_t<E>, Event> and
                 handler_for<Downstream, std::remove_cvref_t<E>>)
    void handle(E &&event) {
        auto const abstime = event.abstime;
        bool const matched = matcher(event);
        bool const pass = PassMatched ? true : not matched;
        if (pass)
            downstream.handle(std::forward<E>(event));
        if (matched)
            downstream.handle(OutEvent{abstime});
    }
 
    template <typename E>
        requires(not std::convertible_to<std::remove_cvref_t<E>, Event> and
                 handler_for<Downstream, std::remove_cvref_t<E>>)
    void handle(E &&event) {
        downstream.handle(std::forward<E>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename Event, typename OutEvent, typename Matcher,
          typename Downstream>
auto match_and_consume(Matcher matcher, Downstream downstream) {
    return internal::match<Event, OutEvent, Matcher, false, Downstream>(
        std::move(matcher), std::move(downstream));
}

template <typename Event, typename OutEvent, typename Matcher,
          typename Downstream>
auto match(Matcher matcher, Downstream downstream) {
    return internal::match<Event, OutEvent, Matcher, true, Downstream>(
        std::move(matcher), std::move(downstream));
}

class always_matcher {
  public:
    template <typename Event>
    auto operator()(Event const & /* event */) const -> bool {
        return true;
    }
};

class never_matcher {
  public:
    template <typename Event>
    auto operator()(Event const & /* event */) const -> bool {
        return false;
    }
};

template <typename NumericTraits = default_numeric_traits>
class channel_matcher {
    NumericTraits::channel_type channel;
 
  public:
    explicit channel_matcher(
        arg::channel<typename NumericTraits::channel_type> channel)
        : channel(channel.value) {}

    template <typename Event>
    auto operator()(Event const &event) const -> bool {
        static_assert(std::is_same_v<decltype(event.channel),
                                     typename NumericTraits::channel_type>);
        return event.channel == channel;
    }
};
 
} // namespace tcspc