gate.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 "processor.hpp"
#include "type_list.hpp"
 
#include <type_traits>
#include <utility>
 
namespace tcspc {
 
namespace internal {
 
template <typename GatedEventList, typename OpenEvent, typename CloseEvent,
          typename Downstream>
class gate {
    static_assert(type_list_like<GatedEventList>);
    // We do not require Downstream to handle all of GatedEventList.
    static_assert(handler_for<Downstream, OpenEvent, CloseEvent>);
 
    bool open;
 
    Downstream downstream;
 
  public:
    explicit gate(arg::initially_open<bool> initially_open,
                  Downstream downstream)
        : open(initially_open.value), downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "gate");
    }
 
    [[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>,
                                            OpenEvent>) {
            open = true;
            downstream.handle(std::forward<E>(event));
        } else if constexpr (std::is_convertible_v<std::remove_cvref_t<E>,
                                                   CloseEvent>) {
            open = false;
            downstream.handle(std::forward<E>(event));
        } else if constexpr (convertible_to_type_list_member<
                                 std::remove_cvref_t<E>, GatedEventList>) {
            if (open)
                downstream.handle(std::forward<E>(event));
        } else {
            downstream.handle(std::forward<E>(event));
        }
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename GatedEventList, typename OpenEvent, typename CloseEvent,
          typename Downstream>
auto gate(arg::initially_open<bool> initially_open, Downstream downstream) {
    return internal::gate<GatedEventList, OpenEvent, CloseEvent, Downstream>(
        initially_open, std::move(downstream));
}
 
} // namespace tcspc