core.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 "introspect.hpp"
 
#include <ostream>
#include <stdexcept>
#include <string>
#include <utility>
 
namespace tcspc {

struct warning_event {
    std::string message;

    friend auto operator==(warning_event const &lhs,
                           warning_event const &rhs) noexcept
        -> bool = default;

    friend auto operator<<(std::ostream &stream, warning_event const &event)
        -> std::ostream & {
        return stream << event.message;
    }
};

struct never_event {
    never_event() = delete;
};

class null_sink {
  public:
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "null_sink");
    }

    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return processor_graph().push_entry_point(this);
    }

    template <typename Event> void handle(Event const & /* event */) {}

    void flush() {}
};
 
namespace internal {
 
template <typename Downstream> class null_source {
    bool flushed = false;
    Downstream downstream;
 
  public:
    explicit null_source(Downstream downstream)
        : downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "null_source");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    void flush() {
        if (flushed) {
            throw std::logic_error(
                "null_source may not be flushed a second time");
        }
        flushed = true;
        downstream.flush();
    }
};
 
} // namespace internal

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