processor.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 "type_list.hpp"
 
#include <concepts>
#include <type_traits>
#include <utility>
 
namespace tcspc {

template <typename Proc>
concept flushable = requires(Proc &p) {
    { p.flush() } -> std::same_as<void>;
};

template <typename Proc, typename Event>
concept rvalue_handler_for = requires(Proc &p, Event &&e) {
    { p.handle(std::move(e)) } -> std::same_as<void>;
};

template <typename Proc, typename Event>
concept const_handler_for = requires(Proc &p, Event const &e) {
    { p.handle(e) } -> std::same_as<void>;
};

template <typename Proc, typename... Events>
concept handler_for = (... && (const_handler_for<Proc, Events> &&
                               rvalue_handler_for<Proc, Events>));

template <typename Proc, typename... Events>
concept processor = flushable<Proc> && handler_for<Proc, Events...>;

 
namespace internal {
 
template <typename Proc, typename TypeList> struct handles_event_list_impl {
    static_assert(type_list_like<TypeList>);
};
 
template <typename Proc, typename... Events>
struct handles_event_list_impl<Proc, type_list<Events...>>
    : std::bool_constant<handler_for<Proc, Events...>> {};
 
} // namespace internal


template <typename Proc, typename EventList>
inline constexpr bool handles_event_list_v =
    internal::handles_event_list_impl<Proc, EventList>::value;

 
namespace internal {
 
template <typename Proc, typename TypeList> struct is_processor_of_list_impl {
    static_assert(type_list_like<TypeList>);
};
 
template <typename Proc, typename... Events>
struct is_processor_of_list_impl<Proc, type_list<Events...>>
    : std::bool_constant<processor<Proc, Events...>> {};
 
} // namespace internal


template <typename Proc, typename EventList>
inline constexpr bool is_processor_of_list_v =
    internal::is_processor_of_list_impl<Proc, EventList>::value;
 
} // namespace tcspc