event_set.hpp

//Copyright Florian Goujeon 2021 - 2026.
//Distributed under the Boost Software License, Version 1.0.
//(See accompanying file LICENSE or copy at
//https://www.boost.org/LICENSE_1_0.txt)
//Official repository: https://github.com/fgoujeon/maki
 
#ifndef MAKI_EVENT_SET_HPP
#define MAKI_EVENT_SET_HPP
 
#include "event.hpp"
#include "detail/type_set.hpp"
#include "detail/friendly_impl.hpp"
 
namespace maki
{

template<class Impl>
class event_set;
 
namespace detail
{
    template<class Impl>
    constexpr event_set<Impl> make_event_set_from_impl()
    {
        return event_set<Impl>{};
    }
}
 
template<class Impl>
class event_set
{
public:
    template<class Event>
    constexpr explicit event_set(event_t<Event> /*evt*/)
    {
    }

    template<class Event>
    [[nodiscard]]
    constexpr bool contains() const
    {
        return detail::type_set_contains_v<Impl, Event>;
    }

    template<class Event>
    [[nodiscard]]
    constexpr bool contains(event_t<Event> /*ignored*/) const
    {
        return detail::type_set_contains_v<Impl, Event>;
    }
 
private:
    using impl_type = Impl;
 
    template<class T>
    friend struct detail::impl_of_t_helper;
 
    template<class Impl2>
    friend constexpr event_set<Impl2> detail::make_event_set_from_impl();
 
    constexpr event_set() = default;
};

template<class Event>
event_set(event_t<Event>) -> event_set
<
#ifdef MAKI_DETAIL_DOXYGEN
    IMPLEMENTATION_DETAIL
#else
    detail::type_set_item<Event>
#endif
>;
 
#ifdef MAKI_DETAIL_DOXYGEN
inline constexpr auto all_events = IMPLEMENTATION_DETAIL;
#else
inline constexpr auto all_events = detail::make_event_set_from_impl
<
    detail::universal_type_set_t
>();
#endif
 
#ifdef MAKI_DETAIL_DOXYGEN
inline constexpr auto no_event = IMPLEMENTATION_DETAIL;
#else
inline constexpr auto no_event = detail::make_event_set_from_impl
<
    detail::empty_type_set_t
>();
#endif

template<class EventSetImpl>
constexpr auto operator!
(
#ifdef MAKI_DETAIL_DOXYGEN
    const event_set<EventSetImpl>& event_types
#else
    const event_set<EventSetImpl>& /*event_types*/
#endif
)
{
    return detail::make_event_set_from_impl
    <
        detail::type_set_inverse_t<EventSetImpl>
    >();
}

template<class Event>
constexpr auto operator!(event_t<Event> /*evt*/)
{
    return detail::make_event_set_from_impl
    <
        detail::type_set_exclusion_list<Event>
    >();
}

template<class LhsImpl, class RhsImpl>
constexpr auto operator||
(
#ifdef MAKI_DETAIL_DOXYGEN
    const event_set<LhsImpl>& lhs,
    const event_set<RhsImpl>& rhs
#else
    const event_set<LhsImpl>& /*lhs*/,
    const event_set<RhsImpl>& /*rhs*/
#endif
)
{
    return detail::make_event_set_from_impl
    <
        detail::type_set_union_t<LhsImpl, RhsImpl>
    >();
}

template<class LhsImpl, class Event>
constexpr auto operator||
(
#ifdef MAKI_DETAIL_DOXYGEN
    const event_set<LhsImpl>& lhs,
    event_t<Event> rhs
#else
    const event_set<LhsImpl>& /*lhs*/,
    event_t<Event> /*rhs*/
#endif
)
{
    return detail::make_event_set_from_impl
    <
        detail::type_set_union_t
        <
            LhsImpl,
            detail::type_set_item<Event>
        >
    >();
}

template<class Event, class RhsImpl>
constexpr auto operator||
(
    const event_t<Event> lhs,
    const event_set<RhsImpl>& rhs
)
{
    return rhs || lhs;
}

template<class LhsEvent, class RhsEvent>
constexpr auto operator||
(
    event_t<LhsEvent> /*lhs*/,
    event_t<RhsEvent> /*rhs*/
)
{
    return detail::make_event_set_from_impl
    <
        detail::type_set_inclusion_list<LhsEvent, RhsEvent>
    >();
}

template<class LhsImpl, class RhsImpl>
constexpr auto operator&&
(
#ifdef MAKI_DETAIL_DOXYGEN
    const event_set<LhsImpl>& lhs,
    const event_set<RhsImpl>& rhs
#else
    const event_set<LhsImpl>& /*lhs*/,
    const event_set<RhsImpl>& /*rhs*/
#endif
)
{
    return detail::make_event_set_from_impl
    <
        detail::type_set_intersection_t<LhsImpl, RhsImpl>
    >();
}
 
namespace detail
{
    template<class T>
    struct is_event_set
    {
        static constexpr auto value = false;
    };
 
    template<class EventSetImpl>
    struct is_event_set<event_set<EventSetImpl>>
    {
        static constexpr auto value = true;
    };
 
    template<class T>
    constexpr auto is_event_set_v = is_event_set<T>::value;
}
 
} //namespace
 
#endif