view_as_bytes.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 "bucket.hpp"
#include "introspect.hpp"
#include "processor.hpp"
 
#include <cstddef>
#include <span>
#include <type_traits>
#include <utility>
 
namespace tcspc {
 
namespace internal {
 
template <typename Downstream> class view_as_bytes {
    static_assert(processor<Downstream, bucket<std::byte>>);
 
    Downstream downstream;
 
  public:
    explicit view_as_bytes(Downstream downstream)
        : downstream(std::move(downstream)) {}
 
    [[nodiscard]] auto introspect_node() const -> processor_info {
        return processor_info(this, "view_as_bytes");
    }
 
    [[nodiscard]] auto introspect_graph() const -> processor_graph {
        return downstream.introspect_graph().push_entry_point(this);
    }
 
    template <typename Event>
        requires std::is_trivial_v<Event>
    void handle(Event const &event) {
        // It is safe to const_cast the bytes because we emit the bucket by
        // const ref.
        auto const_byte_span = std::as_bytes(std::span(&event, 1));
        auto const b = ad_hoc_bucket(std::span<std::byte>(
            const_cast<std::byte *>(const_byte_span.data()),
            const_byte_span.size()));
        downstream.handle(b);
    }
 
    template <typename T>
        requires std::is_trivial_v<T>
    void handle(bucket<T> const &event) {
        // It is safe to const_cast the bytes because we emit the bucket by
        // const ref.
        auto const_byte_span = std::as_bytes(std::span(event));
        auto const b = ad_hoc_bucket(std::span<std::byte>(
            const_cast<std::byte *>(const_byte_span.data()),
            const_byte_span.size()));
        downstream.handle(b);
    }
 
    void flush() { downstream.flush(); }
};
 
} // namespace internal

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