variant_event.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 "event.hpp"
#include "type_list.hpp"
 
#include <ostream>
#include <type_traits>
#include <utility>
#include <variant>
 
namespace tcspc {


template <typename EventList> class variant_event;

 
template <typename... Events>
class variant_event<type_list<Events...>> : public std::variant<Events...> {
    static_assert(sizeof...(Events) > 0,
                  "variant_event cannot have empty EventList");
 
    using base_type = std::variant<Events...>;
    using base_type::base_type;
 
    friend auto operator<<(std::ostream &stream, variant_event const &event)
        -> std::ostream &
        requires(internal::ostreamable<Events> && ...)
    {
        return std::visit(
            [&](auto const &e) -> std::ostream & { return stream << e; },
            event);
    }
};

 
namespace internal {
 
template <typename EventList>
struct variant_or_single_event_impl
    : std::type_identity<variant_event<EventList>> {};
 
template <typename Event>
struct variant_or_single_event_impl<type_list<Event>>
    : std::type_identity<Event> {};
 
} // namespace internal

template <typename EventList>
using variant_or_single_event = internal::variant_or_single_event_impl<
    unique_type_list_t<EventList>>::type;


template <typename Visitor, typename Event>
constexpr auto visit_variant_or_single_event(Visitor visitor, Event &&event) {
    return visitor(std::forward<Event>(event));
}

template <typename Visitor, typename EventList>
constexpr auto
visit_variant_or_single_event(Visitor &&visitor,
                              variant_event<EventList> &&event) {
    return std::visit(std::forward<Visitor>(visitor), std::move(event));
}

template <typename Visitor, typename EventList>
constexpr auto
visit_variant_or_single_event(Visitor &&visitor,
                              variant_event<EventList> const &event) {
    return std::visit(std::forward<Visitor>(visitor), event);
}

template <typename Visitor, typename EventList>
constexpr auto visit_variant_or_single_event(Visitor &&visitor,
                                             variant_event<EventList> &event) {
    return std::visit(std::forward<Visitor>(visitor), event);
}


 
} // namespace tcspc