stop.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 "errors.hpp"
#include "introspect.hpp"
#include "processor.hpp"
#include "type_list.hpp"
 
#include <sstream>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
 
namespace tcspc {
 
namespace internal {
 
template <typename EventList, typename Exception, typename Downstream>
class stop {
    static_assert(type_list_like<EventList>);
    static_assert(processor<Downstream>);
 
    Downstream downstream;
 
    // Cold data after downstream.
    std::string message_prefix;
 
    template <typename Event>
    [[noreturn]] LIBTCSPC_NOINLINE void handle_stop(Event const &event) {
        if constexpr (std::is_same_v<Exception, end_of_processing>)
            downstream.flush();
        std::ostringstream stream;
        if (not message_prefix.empty())
            stream << message_prefix << ": ";
        stream << event;
        throw Exception(stream.str());
    }
 
  public:
    explicit stop(std::string prefix, Downstream downstream)
        : downstream(std::move(downstream)),
          message_prefix(std::move(prefix)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "stop");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename Event>
        requires convertible_to_type_list_member<std::remove_cvref_t<Event>,
                                                 EventList>
    [[noreturn]] void handle(Event &&event) {
        handle_stop(event);
    }
 
    template <typename Event>
        requires(not convertible_to_type_list_member<
                     std::remove_cvref_t<Event>, EventList> and
                 handler_for<Downstream, std::remove_cvref_t<Event>>)
    void handle(Event &&event) {
        downstream.handle(std::forward<Event>(event));
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

template <typename EventList, typename Exception = std::runtime_error,
          typename Downstream>
auto stop_with_error(std::string message_prefix, Downstream downstream) {
    static_assert(not std::is_same_v<Exception, end_of_processing>);
    return internal::stop<EventList, Exception, Downstream>(
        std::move(message_prefix), std::move(downstream));
}

template <typename EventList, typename Downstream>
auto stop(std::string message_prefix, Downstream downstream) {
    return internal::stop<EventList, end_of_processing, Downstream>(
        std::move(message_prefix), std::move(downstream));
}
 
} // namespace tcspc