prepend_append.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 "introspect.hpp"
#include "processor.hpp"
 
#include <type_traits>
 
namespace tcspc {
 
namespace internal {
 
template <typename Event, typename Downstream> class prepend {
    static_assert(processor<Downstream, Event>);
 
    bool prepended = false;
    Downstream downstream;
 
    // Cold data after downstream:
    Event evt;
 
  public:
    explicit prepend(Event event, Downstream downstream)
        : downstream(std::move(downstream)), evt(std::move(event)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "prepend");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename AnyEvent>
        requires handler_for<Downstream, std::remove_cvref_t<AnyEvent>>
    void handle(AnyEvent &&event) {
        if (not prepended) {
            downstream.handle(std::move(evt));
            prepended = true;
        }
        downstream.handle(std::forward<AnyEvent>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
template <typename Event, typename Downstream> class append {
    static_assert(processor<Downstream, Event>);
 
    Downstream downstream;
 
    // Cold data after downstream:
    Event evt;
 
  public:
    explicit append(Event event, Downstream downstream)
        : downstream(std::move(downstream)), evt(std::move(event)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "append");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename AnyEvent>
        requires handler_for<Downstream, std::remove_cvref_t<AnyEvent>>
    void handle(AnyEvent &&event) {
        downstream.handle(std::forward<AnyEvent>(event));
    }
 
    void flush() {
        downstream.handle(std::move(evt));
        downstream.flush();
    }
};
 
} // namespace internal

template <typename Event, typename Downstream>
auto prepend(Event event, Downstream downstream) {
    return internal::prepend<Event, Downstream>(std::move(event),
                                                std::move(downstream));
}

template <typename Event, typename Downstream>
auto append(Event event, Downstream downstream) {
    return internal::append<Event, Downstream>(std::move(event),
                                               std::move(downstream));
}
 
} // namespace tcspc