entt.hpp

Go to the documentation of this file.

#ifdef min
#undef min
#endif
 
// #include "core/algorithm.hpp"
#ifndef ENTT_CORE_ALGORITHM_HPP
#define ENTT_CORE_ALGORITHM_HPP
 
 
#include <utility>
#include <iterator>
#include <algorithm>
#include <functional>
// #include "utility.hpp"
#ifndef ENTT_CORE_UTILITY_HPP
#define ENTT_CORE_UTILITY_HPP
 
 
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
struct identity {
    template<class Type>
    constexpr Type && operator()(Type &&value) const ENTT_NOEXCEPT {
        return std::forward<Type>(value);
    }
};
 
 
template<typename Type, typename Class>
constexpr auto overload(Type Class:: *member) ENTT_NOEXCEPT { return member; }
 
 
template<typename Type>
constexpr auto overload(Type *func) ENTT_NOEXCEPT { return func; }
 
 
template<class... Func>
struct overloaded: Func... {
    using Func::operator()...;
};
 
 
template<class... Type>
overloaded(Type...) -> overloaded<Type...>;
 
 
template<class Func>
struct y_combinator {
    y_combinator(Func recursive):
        func{std::move(recursive)}
    {}
 
    template <class... Args>
    decltype(auto) operator()(Args &&... args) const {
        return func(*this, std::forward<Args>(args)...);
    }
 
    template <class... Args>
    decltype(auto) operator()(Args &&... args) {
        return func(*this, std::forward<Args>(args)...);
    }
 
private:
    Func func;
};
 
 
}
 
 
#endif // ENTT_CORE_UTILITY_HPP
 
 
 
namespace entt {
 
 
struct std_sort {
    template<typename It, typename Compare = std::less<>, typename... Args>
    void operator()(It first, It last, Compare compare = Compare{}, Args &&... args) const {
        std::sort(std::forward<Args>(args)..., std::move(first), std::move(last), std::move(compare));
    }
};
 
 
struct insertion_sort {
    template<typename It, typename Compare = std::less<>>
    void operator()(It first, It last, Compare compare = Compare{}) const {
        if(first < last) {
            for(auto it = first+1; it < last; ++it) {
                auto value = std::move(*it);
                auto pre = it;
 
                for(; pre > first && compare(value, *(pre-1)); --pre) {
                    *pre = std::move(*(pre-1));
                }
 
                *pre = std::move(value);
            }
        }
    }
};
 
 
template<std::size_t Bit, std::size_t N>
struct radix_sort {
    static_assert((N % Bit) == 0);
 
    template<typename It, typename Getter = identity>
    void operator()(It first, It last, Getter getter = Getter{}) const {
        if(first < last) {
            static constexpr auto mask = (1 << Bit) - 1;
            static constexpr auto buckets = 1 << Bit;
            static constexpr auto passes = N / Bit;
 
            using value_type = typename std::iterator_traits<It>::value_type;
            std::vector<value_type> aux(std::distance(first, last));
 
            auto part = [getter = std::move(getter)](auto from, auto to, auto out, auto start) {
                std::size_t index[buckets]{};
                std::size_t count[buckets]{};
 
                std::for_each(from, to, [&getter, &count, start](const value_type &item) {
                    ++count[(getter(item) >> start) & mask];
                });
 
                std::for_each(std::next(std::begin(index)), std::end(index), [index = std::begin(index), count = std::begin(count)](auto &item) mutable {
                    item = *(index++) + *(count++);
                });
 
                std::for_each(from, to, [&getter, &out, &index, start](value_type &item) {
                    out[index[(getter(item) >> start) & mask]++] = std::move(item);
                });
            };
 
            for(std::size_t pass = 0; pass < (passes & ~1); pass += 2) {
                part(first, last, aux.begin(), pass * Bit);
                part(aux.begin(), aux.end(), first, (pass + 1) * Bit);
            }
 
            if constexpr(passes & 1) {
                part(first, last, aux.begin(), (passes - 1) * Bit);
                std::move(aux.begin(), aux.end(), first);
            }
        }
    }
};
 
 
}
 
 
#endif // ENTT_CORE_ALGORITHM_HPP
 
// #include "core/family.hpp"
#ifndef ENTT_CORE_FAMILY_HPP
#define ENTT_CORE_FAMILY_HPP
 
 
#include <type_traits>
// #include "../config/config.h"
 
 
 
namespace entt {
 
 
template<typename...>
class family {
    inline static ENTT_MAYBE_ATOMIC(ENTT_ID_TYPE) identifier{};
 
public:
    using family_type = ENTT_ID_TYPE;
 
    template<typename... Type>
    // at the time I'm writing, clang crashes during compilation if auto is used instead of family_type
    inline static const family_type type = identifier++;
};
 
 
}
 
 
#endif // ENTT_CORE_FAMILY_HPP
 
// #include "core/hashed_string.hpp"
#ifndef ENTT_CORE_HASHED_STRING_HPP
#define ENTT_CORE_HASHED_STRING_HPP
 
 
#include <cstddef>
// #include "../config/config.h"
 
 
 
namespace entt {
 
 
namespace internal {
 
 
template<typename>
struct fnv1a_traits;
 
 
template<>
struct fnv1a_traits<std::uint32_t> {
    static constexpr std::uint32_t offset = 2166136261;
    static constexpr std::uint32_t prime = 16777619;
};
 
 
template<>
struct fnv1a_traits<std::uint64_t> {
    static constexpr std::uint64_t offset = 14695981039346656037ull;
    static constexpr std::uint64_t prime = 1099511628211ull;
};
 
 
}
 
 
template<typename Char>
class basic_hashed_string {
    using traits_type = internal::fnv1a_traits<ENTT_ID_TYPE>;
 
    struct const_wrapper {
        // non-explicit constructor on purpose
        constexpr const_wrapper(const Char *curr) ENTT_NOEXCEPT: str{curr} {}
        const Char *str;
    };
 
    // Fowler–Noll–Vo hash function v. 1a - the good
    static constexpr ENTT_ID_TYPE helper(ENTT_ID_TYPE partial, const Char *curr) ENTT_NOEXCEPT {
        return curr[0] == 0 ? partial : helper((partial^curr[0])*traits_type::prime, curr+1);
    }
 
public:
    using value_type = Char;
    using hash_type = ENTT_ID_TYPE;
 
    template<std::size_t N>
    static constexpr hash_type to_value(const value_type (&str)[N]) ENTT_NOEXCEPT {
        return helper(traits_type::offset, str);
    }
 
    static hash_type to_value(const_wrapper wrapper) ENTT_NOEXCEPT {
        return helper(traits_type::offset, wrapper.str);
    }
 
    static hash_type to_value(const value_type *str, std::size_t size) ENTT_NOEXCEPT {
        ENTT_ID_TYPE partial{traits_type::offset};
        while(size--) { partial = (partial^(str++)[0])*traits_type::prime; }
        return partial;
    }
 
    constexpr basic_hashed_string() ENTT_NOEXCEPT
        : str{nullptr}, hash{}
    {}
 
    template<std::size_t N>
    constexpr basic_hashed_string(const value_type (&curr)[N]) ENTT_NOEXCEPT
        : str{curr}, hash{helper(traits_type::offset, curr)}
    {}
 
    explicit constexpr basic_hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT
        : str{wrapper.str}, hash{helper(traits_type::offset, wrapper.str)}
    {}
 
    constexpr const value_type * data() const ENTT_NOEXCEPT {
        return str;
    }
 
    constexpr hash_type value() const ENTT_NOEXCEPT {
        return hash;
    }
 
    constexpr operator const value_type *() const ENTT_NOEXCEPT { return str; }
 
    constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
 
    constexpr bool operator==(const basic_hashed_string &other) const ENTT_NOEXCEPT {
        return hash == other.hash;
    }
 
private:
    const value_type *str;
    hash_type hash;
};
 
 
template<typename Char, std::size_t N>
basic_hashed_string(const Char (&str)[N]) ENTT_NOEXCEPT
-> basic_hashed_string<Char>;
 
 
template<typename Char>
constexpr bool operator!=(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
using hashed_string = basic_hashed_string<char>;
 
 
using hashed_wstring = basic_hashed_string<wchar_t>;
 
 
}
 
 
constexpr entt::hashed_string operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_string{str};
}
 
 
constexpr entt::hashed_wstring operator"" ENTT_HWS_SUFFIX(const wchar_t *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_wstring{str};
}
 
 
#endif // ENTT_CORE_HASHED_STRING_HPP
 
// #include "core/ident.hpp"
#ifndef ENTT_CORE_IDENT_HPP
#define ENTT_CORE_IDENT_HPP
 
 
#include <tuple>
#include <utility>
#include <type_traits>
// #include "../config/config.h"
 
 
 
namespace entt {
 
 
template<typename... Types>
class identifier {
    using tuple_type = std::tuple<std::decay_t<Types>...>;
 
    template<typename Type, std::size_t... Indexes>
    static constexpr ENTT_ID_TYPE get(std::index_sequence<Indexes...>) ENTT_NOEXCEPT {
        static_assert(std::disjunction_v<std::is_same<Type, Types>...>);
        return (0 + ... + (std::is_same_v<Type, std::tuple_element_t<Indexes, tuple_type>> ? ENTT_ID_TYPE(Indexes) : ENTT_ID_TYPE{}));
    }
 
public:
    using identifier_type = ENTT_ID_TYPE;
 
    template<typename Type>
    static constexpr identifier_type type = get<std::decay_t<Type>>(std::index_sequence_for<Types...>{});
};
 
 
}
 
 
#endif // ENTT_CORE_IDENT_HPP
 
// #include "core/monostate.hpp"
#ifndef ENTT_CORE_MONOSTATE_HPP
#define ENTT_CORE_MONOSTATE_HPP
 
 
#include <cassert>
// #include "../config/config.h"
 
 
 
namespace entt {
 
 
template<ENTT_ID_TYPE>
struct monostate {
    template<typename Type>
    void operator=(Type val) const ENTT_NOEXCEPT {
        value<Type> = val;
    }
 
    template<typename Type>
    operator Type() const ENTT_NOEXCEPT {
        return value<Type>;
    }
 
private:
    template<typename Type>
    inline static ENTT_MAYBE_ATOMIC(Type) value{};
};
 
 
template<ENTT_ID_TYPE Value>
inline monostate<Value> monostate_v = {};
 
 
}
 
 
#endif // ENTT_CORE_MONOSTATE_HPP
 
// #include "core/type_traits.hpp"
#ifndef ENTT_CORE_TYPE_TRAITS_HPP
#define ENTT_CORE_TYPE_TRAITS_HPP
 
 
#include <cstddef>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/hashed_string.hpp"
#ifndef ENTT_CORE_HASHED_STRING_HPP
#define ENTT_CORE_HASHED_STRING_HPP
 
 
#include <cstddef>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
namespace internal {
 
 
template<typename>
struct fnv1a_traits;
 
 
template<>
struct fnv1a_traits<std::uint32_t> {
    static constexpr std::uint32_t offset = 2166136261;
    static constexpr std::uint32_t prime = 16777619;
};
 
 
template<>
struct fnv1a_traits<std::uint64_t> {
    static constexpr std::uint64_t offset = 14695981039346656037ull;
    static constexpr std::uint64_t prime = 1099511628211ull;
};
 
 
}
 
 
template<typename Char>
class basic_hashed_string {
    using traits_type = internal::fnv1a_traits<ENTT_ID_TYPE>;
 
    struct const_wrapper {
        // non-explicit constructor on purpose
        constexpr const_wrapper(const Char *curr) ENTT_NOEXCEPT: str{curr} {}
        const Char *str;
    };
 
    // Fowler–Noll–Vo hash function v. 1a - the good
    static constexpr ENTT_ID_TYPE helper(ENTT_ID_TYPE partial, const Char *curr) ENTT_NOEXCEPT {
        return curr[0] == 0 ? partial : helper((partial^curr[0])*traits_type::prime, curr+1);
    }
 
public:
    using value_type = Char;
    using hash_type = ENTT_ID_TYPE;
 
    template<std::size_t N>
    static constexpr hash_type to_value(const value_type (&str)[N]) ENTT_NOEXCEPT {
        return helper(traits_type::offset, str);
    }
 
    static hash_type to_value(const_wrapper wrapper) ENTT_NOEXCEPT {
        return helper(traits_type::offset, wrapper.str);
    }
 
    static hash_type to_value(const value_type *str, std::size_t size) ENTT_NOEXCEPT {
        ENTT_ID_TYPE partial{traits_type::offset};
        while(size--) { partial = (partial^(str++)[0])*traits_type::prime; }
        return partial;
    }
 
    constexpr basic_hashed_string() ENTT_NOEXCEPT
        : str{nullptr}, hash{}
    {}
 
    template<std::size_t N>
    constexpr basic_hashed_string(const value_type (&curr)[N]) ENTT_NOEXCEPT
        : str{curr}, hash{helper(traits_type::offset, curr)}
    {}
 
    explicit constexpr basic_hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT
        : str{wrapper.str}, hash{helper(traits_type::offset, wrapper.str)}
    {}
 
    constexpr const value_type * data() const ENTT_NOEXCEPT {
        return str;
    }
 
    constexpr hash_type value() const ENTT_NOEXCEPT {
        return hash;
    }
 
    constexpr operator const value_type *() const ENTT_NOEXCEPT { return str; }
 
    constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
 
    constexpr bool operator==(const basic_hashed_string &other) const ENTT_NOEXCEPT {
        return hash == other.hash;
    }
 
private:
    const value_type *str;
    hash_type hash;
};
 
 
template<typename Char, std::size_t N>
basic_hashed_string(const Char (&str)[N]) ENTT_NOEXCEPT
-> basic_hashed_string<Char>;
 
 
template<typename Char>
constexpr bool operator!=(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
using hashed_string = basic_hashed_string<char>;
 
 
using hashed_wstring = basic_hashed_string<wchar_t>;
 
 
}
 
 
constexpr entt::hashed_string operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_string{str};
}
 
 
constexpr entt::hashed_wstring operator"" ENTT_HWS_SUFFIX(const wchar_t *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_wstring{str};
}
 
 
#endif // ENTT_CORE_HASHED_STRING_HPP
 
 
 
namespace entt {
 
 
template<std::size_t N>
struct choice_t
        // Unfortunately, doxygen cannot parse such a construct.
        : choice_t<N-1>
{};
 
 
template<>
struct choice_t<0> {};
 
 
template<std::size_t N>
constexpr choice_t<N> choice{};
 
 
template<typename...>
struct type_list {};
 
 
template<typename>
struct type_list_size;
 
 
template<typename... Type>
struct type_list_size<type_list<Type...>>
        : std::integral_constant<std::size_t, sizeof...(Type)>
{};
 
 
template<class List>
constexpr auto type_list_size_v = type_list_size<List>::value;
 
 
template<typename...>
struct type_list_cat;
 
 
template<>
struct type_list_cat<> {
    using type = type_list<>;
};
 
 
template<typename... Type, typename... Other, typename... List>
struct type_list_cat<type_list<Type...>, type_list<Other...>, List...> {
    using type = typename type_list_cat<type_list<Type..., Other...>, List...>::type;
};
 
 
template<typename... Type>
struct type_list_cat<type_list<Type...>> {
    using type = type_list<Type...>;
};
 
 
template<typename... List>
using type_list_cat_t = typename type_list_cat<List...>::type;
 
 
template<typename>
struct type_list_unique;
 
 
template<typename Type, typename... Other>
struct type_list_unique<type_list<Type, Other...>> {
    using type = std::conditional_t<
        std::disjunction_v<std::is_same<Type, Other>...>,
        typename type_list_unique<type_list<Other...>>::type,
        type_list_cat_t<type_list<Type>, typename type_list_unique<type_list<Other...>>::type>
    >;
};
 
 
template<>
struct type_list_unique<type_list<>> {
    using type = type_list<>;
};
 
 
template<typename Type>
using type_list_unique_t = typename type_list_unique<Type>::type;
 
 
template<typename Type, typename = std::void_t<>>
struct is_equality_comparable: std::false_type {};
 
 
template<typename Type>
struct is_equality_comparable<Type, std::void_t<decltype(std::declval<Type>() == std::declval<Type>())>>: std::true_type {};
 
 
template<class Type>
constexpr auto is_equality_comparable_v = is_equality_comparable<Type>::value;
 
 
template<typename>
struct named_type_traits;
 
 
template<typename Type>
struct named_type_traits<const Type>
        : named_type_traits<Type>
{};
 
 
template<typename Type>
using named_type_traits_t = typename named_type_traits<Type>::type;
 
 
template<class Type>
constexpr auto named_type_traits_v = named_type_traits<Type>::value;
 
 
template<typename Type, typename = std::void_t<>>
struct is_named_type: std::false_type {};
 
 
template<typename Type>
struct is_named_type<Type, std::void_t<named_type_traits_t<std::decay_t<Type>>>>: std::true_type {};
 
 
template<class Type>
constexpr auto is_named_type_v = is_named_type<Type>::value;
 
 
#define ENTT_OPAQUE_TYPE(clazz, type)\
    enum class clazz: type {};\
    constexpr auto to_integer(const clazz id) ENTT_NOEXCEPT {\
        return std::underlying_type_t<clazz>(id);\
    }\
    static_assert(true)
 
 
}
 
 
#define ENTT_EXPAND(args) args
 
 
#define ENTT_NAMED_TYPE(type)\
    template<>\
    struct entt::named_type_traits<type>\
        : std::integral_constant<ENTT_ID_TYPE, entt::basic_hashed_string<std::remove_cv_t<std::remove_pointer_t<std::decay_t<decltype(#type)>>>>{#type}>\
    {\
        static_assert(std::is_same_v<std::remove_cv_t<type>, type>);\
        static_assert(std::is_object_v<type>);\
    }
 
 
#define ENTT_NAMED_STRUCT_ONLY(clazz, body)\
    struct clazz body;\
    ENTT_NAMED_TYPE(clazz)
 
 
#define ENTT_NAMED_STRUCT_WITH_NAMESPACE(ns, clazz, body)\
    namespace ns { struct clazz body; }\
    ENTT_NAMED_TYPE(ns::clazz)
 
 
#define ENTT_NAMED_STRUCT_OVERLOAD(_1, _2, _3, FUNC, ...) FUNC
 
#define ENTT_NAMED_STRUCT(...) ENTT_EXPAND(ENTT_NAMED_STRUCT_OVERLOAD(__VA_ARGS__, ENTT_NAMED_STRUCT_WITH_NAMESPACE, ENTT_NAMED_STRUCT_ONLY,)(__VA_ARGS__))
 
 
#define ENTT_NAMED_CLASS_ONLY(clazz, body)\
    class clazz body;\
    ENTT_NAMED_TYPE(clazz)
 
 
#define ENTT_NAMED_CLASS_WITH_NAMESPACE(ns, clazz, body)\
    namespace ns { class clazz body; }\
    ENTT_NAMED_TYPE(ns::clazz)
 
 
#define ENTT_NAMED_CLASS_MACRO(_1, _2, _3, FUNC, ...) FUNC
 
#define ENTT_NAMED_CLASS(...) ENTT_EXPAND(ENTT_NAMED_CLASS_MACRO(__VA_ARGS__, ENTT_NAMED_CLASS_WITH_NAMESPACE, ENTT_NAMED_CLASS_ONLY,)(__VA_ARGS__))
 
 
#endif // ENTT_CORE_TYPE_TRAITS_HPP
 
// #include "core/utility.hpp"
 
// #include "entity/actor.hpp"
#ifndef ENTT_ENTITY_ACTOR_HPP
#define ENTT_ENTITY_ACTOR_HPP
 
 
#include <cassert>
#include <utility>
#include <type_traits>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
// #include "registry.hpp"
#ifndef ENTT_ENTITY_REGISTRY_HPP
#define ENTT_ENTITY_REGISTRY_HPP
 
 
#include <tuple>
#include <vector>
#include <memory>
#include <utility>
#include <cstddef>
#include <iterator>
#include <algorithm>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/family.hpp"
#ifndef ENTT_CORE_FAMILY_HPP
#define ENTT_CORE_FAMILY_HPP
 
 
#include <type_traits>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
template<typename...>
class family {
    inline static ENTT_MAYBE_ATOMIC(ENTT_ID_TYPE) identifier{};
 
public:
    using family_type = ENTT_ID_TYPE;
 
    template<typename... Type>
    // at the time I'm writing, clang crashes during compilation if auto is used instead of family_type
    inline static const family_type type = identifier++;
};
 
 
}
 
 
#endif // ENTT_CORE_FAMILY_HPP
 
// #include "../core/algorithm.hpp"
#ifndef ENTT_CORE_ALGORITHM_HPP
#define ENTT_CORE_ALGORITHM_HPP
 
 
#include <utility>
#include <iterator>
#include <algorithm>
#include <functional>
// #include "utility.hpp"
#ifndef ENTT_CORE_UTILITY_HPP
#define ENTT_CORE_UTILITY_HPP
 
 
// #include "../config/config.h"
 
 
 
namespace entt {
 
 
struct identity {
    template<class Type>
    constexpr Type && operator()(Type &&value) const ENTT_NOEXCEPT {
        return std::forward<Type>(value);
    }
};
 
 
template<typename Type, typename Class>
constexpr auto overload(Type Class:: *member) ENTT_NOEXCEPT { return member; }
 
 
template<typename Type>
constexpr auto overload(Type *func) ENTT_NOEXCEPT { return func; }
 
 
template<class... Func>
struct overloaded: Func... {
    using Func::operator()...;
};
 
 
template<class... Type>
overloaded(Type...) -> overloaded<Type...>;
 
 
template<class Func>
struct y_combinator {
    y_combinator(Func recursive):
        func{std::move(recursive)}
    {}
 
    template <class... Args>
    decltype(auto) operator()(Args &&... args) const {
        return func(*this, std::forward<Args>(args)...);
    }
 
    template <class... Args>
    decltype(auto) operator()(Args &&... args) {
        return func(*this, std::forward<Args>(args)...);
    }
 
private:
    Func func;
};
 
 
}
 
 
#endif // ENTT_CORE_UTILITY_HPP
 
 
 
namespace entt {
 
 
struct std_sort {
    template<typename It, typename Compare = std::less<>, typename... Args>
    void operator()(It first, It last, Compare compare = Compare{}, Args &&... args) const {
        std::sort(std::forward<Args>(args)..., std::move(first), std::move(last), std::move(compare));
    }
};
 
 
struct insertion_sort {
    template<typename It, typename Compare = std::less<>>
    void operator()(It first, It last, Compare compare = Compare{}) const {
        if(first < last) {
            for(auto it = first+1; it < last; ++it) {
                auto value = std::move(*it);
                auto pre = it;
 
                for(; pre > first && compare(value, *(pre-1)); --pre) {
                    *pre = std::move(*(pre-1));
                }
 
                *pre = std::move(value);
            }
        }
    }
};
 
 
template<std::size_t Bit, std::size_t N>
struct radix_sort {
    static_assert((N % Bit) == 0);
 
    template<typename It, typename Getter = identity>
    void operator()(It first, It last, Getter getter = Getter{}) const {
        if(first < last) {
            static constexpr auto mask = (1 << Bit) - 1;
            static constexpr auto buckets = 1 << Bit;
            static constexpr auto passes = N / Bit;
 
            using value_type = typename std::iterator_traits<It>::value_type;
            std::vector<value_type> aux(std::distance(first, last));
 
            auto part = [getter = std::move(getter)](auto from, auto to, auto out, auto start) {
                std::size_t index[buckets]{};
                std::size_t count[buckets]{};
 
                std::for_each(from, to, [&getter, &count, start](const value_type &item) {
                    ++count[(getter(item) >> start) & mask];
                });
 
                std::for_each(std::next(std::begin(index)), std::end(index), [index = std::begin(index), count = std::begin(count)](auto &item) mutable {
                    item = *(index++) + *(count++);
                });
 
                std::for_each(from, to, [&getter, &out, &index, start](value_type &item) {
                    out[index[(getter(item) >> start) & mask]++] = std::move(item);
                });
            };
 
            for(std::size_t pass = 0; pass < (passes & ~1); pass += 2) {
                part(first, last, aux.begin(), pass * Bit);
                part(aux.begin(), aux.end(), first, (pass + 1) * Bit);
            }
 
            if constexpr(passes & 1) {
                part(first, last, aux.begin(), (passes - 1) * Bit);
                std::move(aux.begin(), aux.end(), first);
            }
        }
    }
};
 
 
}
 
 
#endif // ENTT_CORE_ALGORITHM_HPP
 
// #include "../core/type_traits.hpp"
#ifndef ENTT_CORE_TYPE_TRAITS_HPP
#define ENTT_CORE_TYPE_TRAITS_HPP
 
 
#include <cstddef>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/hashed_string.hpp"
#ifndef ENTT_CORE_HASHED_STRING_HPP
#define ENTT_CORE_HASHED_STRING_HPP
 
 
#include <cstddef>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
namespace internal {
 
 
template<typename>
struct fnv1a_traits;
 
 
template<>
struct fnv1a_traits<std::uint32_t> {
    static constexpr std::uint32_t offset = 2166136261;
    static constexpr std::uint32_t prime = 16777619;
};
 
 
template<>
struct fnv1a_traits<std::uint64_t> {
    static constexpr std::uint64_t offset = 14695981039346656037ull;
    static constexpr std::uint64_t prime = 1099511628211ull;
};
 
 
}
 
 
template<typename Char>
class basic_hashed_string {
    using traits_type = internal::fnv1a_traits<ENTT_ID_TYPE>;
 
    struct const_wrapper {
        // non-explicit constructor on purpose
        constexpr const_wrapper(const Char *curr) ENTT_NOEXCEPT: str{curr} {}
        const Char *str;
    };
 
    // Fowler–Noll–Vo hash function v. 1a - the good
    static constexpr ENTT_ID_TYPE helper(ENTT_ID_TYPE partial, const Char *curr) ENTT_NOEXCEPT {
        return curr[0] == 0 ? partial : helper((partial^curr[0])*traits_type::prime, curr+1);
    }
 
public:
    using value_type = Char;
    using hash_type = ENTT_ID_TYPE;
 
    template<std::size_t N>
    static constexpr hash_type to_value(const value_type (&str)[N]) ENTT_NOEXCEPT {
        return helper(traits_type::offset, str);
    }
 
    static hash_type to_value(const_wrapper wrapper) ENTT_NOEXCEPT {
        return helper(traits_type::offset, wrapper.str);
    }
 
    static hash_type to_value(const value_type *str, std::size_t size) ENTT_NOEXCEPT {
        ENTT_ID_TYPE partial{traits_type::offset};
        while(size--) { partial = (partial^(str++)[0])*traits_type::prime; }
        return partial;
    }
 
    constexpr basic_hashed_string() ENTT_NOEXCEPT
        : str{nullptr}, hash{}
    {}
 
    template<std::size_t N>
    constexpr basic_hashed_string(const value_type (&curr)[N]) ENTT_NOEXCEPT
        : str{curr}, hash{helper(traits_type::offset, curr)}
    {}
 
    explicit constexpr basic_hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT
        : str{wrapper.str}, hash{helper(traits_type::offset, wrapper.str)}
    {}
 
    constexpr const value_type * data() const ENTT_NOEXCEPT {
        return str;
    }
 
    constexpr hash_type value() const ENTT_NOEXCEPT {
        return hash;
    }
 
    constexpr operator const value_type *() const ENTT_NOEXCEPT { return str; }
 
    constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
 
    constexpr bool operator==(const basic_hashed_string &other) const ENTT_NOEXCEPT {
        return hash == other.hash;
    }
 
private:
    const value_type *str;
    hash_type hash;
};
 
 
template<typename Char, std::size_t N>
basic_hashed_string(const Char (&str)[N]) ENTT_NOEXCEPT
-> basic_hashed_string<Char>;
 
 
template<typename Char>
constexpr bool operator!=(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
using hashed_string = basic_hashed_string<char>;
 
 
using hashed_wstring = basic_hashed_string<wchar_t>;
 
 
}
 
 
constexpr entt::hashed_string operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_string{str};
}
 
 
constexpr entt::hashed_wstring operator"" ENTT_HWS_SUFFIX(const wchar_t *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_wstring{str};
}
 
 
#endif // ENTT_CORE_HASHED_STRING_HPP
 
 
 
namespace entt {
 
 
template<std::size_t N>
struct choice_t
        // Unfortunately, doxygen cannot parse such a construct.
        : choice_t<N-1>
{};
 
 
template<>
struct choice_t<0> {};
 
 
template<std::size_t N>
constexpr choice_t<N> choice{};
 
 
template<typename...>
struct type_list {};
 
 
template<typename>
struct type_list_size;
 
 
template<typename... Type>
struct type_list_size<type_list<Type...>>
        : std::integral_constant<std::size_t, sizeof...(Type)>
{};
 
 
template<class List>
constexpr auto type_list_size_v = type_list_size<List>::value;
 
 
template<typename...>
struct type_list_cat;
 
 
template<>
struct type_list_cat<> {
    using type = type_list<>;
};
 
 
template<typename... Type, typename... Other, typename... List>
struct type_list_cat<type_list<Type...>, type_list<Other...>, List...> {
    using type = typename type_list_cat<type_list<Type..., Other...>, List...>::type;
};
 
 
template<typename... Type>
struct type_list_cat<type_list<Type...>> {
    using type = type_list<Type...>;
};
 
 
template<typename... List>
using type_list_cat_t = typename type_list_cat<List...>::type;
 
 
template<typename>
struct type_list_unique;
 
 
template<typename Type, typename... Other>
struct type_list_unique<type_list<Type, Other...>> {
    using type = std::conditional_t<
        std::disjunction_v<std::is_same<Type, Other>...>,
        typename type_list_unique<type_list<Other...>>::type,
        type_list_cat_t<type_list<Type>, typename type_list_unique<type_list<Other...>>::type>
    >;
};
 
 
template<>
struct type_list_unique<type_list<>> {
    using type = type_list<>;
};
 
 
template<typename Type>
using type_list_unique_t = typename type_list_unique<Type>::type;
 
 
template<typename Type, typename = std::void_t<>>
struct is_equality_comparable: std::false_type {};
 
 
template<typename Type>
struct is_equality_comparable<Type, std::void_t<decltype(std::declval<Type>() == std::declval<Type>())>>: std::true_type {};
 
 
template<class Type>
constexpr auto is_equality_comparable_v = is_equality_comparable<Type>::value;
 
 
template<typename>
struct named_type_traits;
 
 
template<typename Type>
struct named_type_traits<const Type>
        : named_type_traits<Type>
{};
 
 
template<typename Type>
using named_type_traits_t = typename named_type_traits<Type>::type;
 
 
template<class Type>
constexpr auto named_type_traits_v = named_type_traits<Type>::value;
 
 
template<typename Type, typename = std::void_t<>>
struct is_named_type: std::false_type {};
 
 
template<typename Type>
struct is_named_type<Type, std::void_t<named_type_traits_t<std::decay_t<Type>>>>: std::true_type {};
 
 
template<class Type>
constexpr auto is_named_type_v = is_named_type<Type>::value;
 
 
#define ENTT_OPAQUE_TYPE(clazz, type)\
    enum class clazz: type {};\
    constexpr auto to_integer(const clazz id) ENTT_NOEXCEPT {\
        return std::underlying_type_t<clazz>(id);\
    }\
    static_assert(true)
 
 
}
 
 
#define ENTT_EXPAND(args) args
 
 
#define ENTT_NAMED_TYPE(type)\
    template<>\
    struct entt::named_type_traits<type>\
        : std::integral_constant<ENTT_ID_TYPE, entt::basic_hashed_string<std::remove_cv_t<std::remove_pointer_t<std::decay_t<decltype(#type)>>>>{#type}>\
    {\
        static_assert(std::is_same_v<std::remove_cv_t<type>, type>);\
        static_assert(std::is_object_v<type>);\
    }
 
 
#define ENTT_NAMED_STRUCT_ONLY(clazz, body)\
    struct clazz body;\
    ENTT_NAMED_TYPE(clazz)
 
 
#define ENTT_NAMED_STRUCT_WITH_NAMESPACE(ns, clazz, body)\
    namespace ns { struct clazz body; }\
    ENTT_NAMED_TYPE(ns::clazz)
 
 
#define ENTT_NAMED_STRUCT_OVERLOAD(_1, _2, _3, FUNC, ...) FUNC
 
#define ENTT_NAMED_STRUCT(...) ENTT_EXPAND(ENTT_NAMED_STRUCT_OVERLOAD(__VA_ARGS__, ENTT_NAMED_STRUCT_WITH_NAMESPACE, ENTT_NAMED_STRUCT_ONLY,)(__VA_ARGS__))
 
 
#define ENTT_NAMED_CLASS_ONLY(clazz, body)\
    class clazz body;\
    ENTT_NAMED_TYPE(clazz)
 
 
#define ENTT_NAMED_CLASS_WITH_NAMESPACE(ns, clazz, body)\
    namespace ns { class clazz body; }\
    ENTT_NAMED_TYPE(ns::clazz)
 
 
#define ENTT_NAMED_CLASS_MACRO(_1, _2, _3, FUNC, ...) FUNC
 
#define ENTT_NAMED_CLASS(...) ENTT_EXPAND(ENTT_NAMED_CLASS_MACRO(__VA_ARGS__, ENTT_NAMED_CLASS_WITH_NAMESPACE, ENTT_NAMED_CLASS_ONLY,)(__VA_ARGS__))
 
 
#endif // ENTT_CORE_TYPE_TRAITS_HPP
 
// #include "../signal/delegate.hpp"
#ifndef ENTT_SIGNAL_DELEGATE_HPP
#define ENTT_SIGNAL_DELEGATE_HPP
 
 
#include <tuple>
#include <cstring>
#include <utility>
#include <algorithm>
#include <functional>
#include <type_traits>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
namespace internal {
 
 
template<typename Ret, typename... Args>
auto to_function_pointer(Ret(*)(Args...)) -> Ret(*)(Args...);
 
 
template<typename Ret, typename... Args, typename Type, typename Payload, typename = std::enable_if_t<std::is_convertible_v<const Payload *, const Type *>>>
auto to_function_pointer(Ret(*)(Type &, Args...), const Payload *) -> Ret(*)(Args...);
 
 
template<typename Ret, typename... Args, typename Type, typename Payload, typename = std::enable_if_t<std::is_convertible_v<const Payload *, const Type *>>>
auto to_function_pointer(Ret(*)(Type *, Args...), const Payload *) -> Ret(*)(Args...);
 
 
template<typename Class, typename Ret, typename... Args>
auto to_function_pointer(Ret(Class:: *)(Args...), const Class *) -> Ret(*)(Args...);
 
 
template<typename Class, typename Ret, typename... Args>
auto to_function_pointer(Ret(Class:: *)(Args...) const, const Class *) -> Ret(*)(Args...);
 
 
template<typename Class, typename Type>
auto to_function_pointer(Type Class:: *, const Class *) -> Type(*)();
 
 
template<typename... Type>
using to_function_pointer_t = decltype(internal::to_function_pointer(std::declval<Type>()...));
 
 
template<typename Ret, typename... Args>
constexpr auto index_sequence_for(Ret(*)(Args...)) {
    return std::index_sequence_for<Args...>{};
}
 
 
}
 
 
template<auto>
struct connect_arg_t {};
 
 
template<auto Func>
constexpr connect_arg_t<Func> connect_arg{};
 
 
template<typename>
class delegate;
 
 
template<typename Ret, typename... Args>
class delegate<Ret(Args...)> {
    using proto_fn_type = Ret(const void *, std::tuple<Args &&...>);
 
    template<auto Function, std::size_t... Index>
    void connect(std::index_sequence<Index...>) ENTT_NOEXCEPT {
        static_assert(std::is_invocable_r_v<Ret, decltype(Function), std::tuple_element_t<Index, std::tuple<Args...>>...>);
        data = nullptr;
 
        fn = [](const void *, std::tuple<Args &&...> args) -> Ret {
            // Ret(...) makes void(...) eat the return values to avoid errors
            return Ret(std::invoke(Function, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
        };
    }
 
    template<auto Candidate, typename Type, std::size_t... Index>
    void connect(Type &value_or_instance, std::index_sequence<Index...>) ENTT_NOEXCEPT {
        static_assert(std::is_invocable_r_v<Ret, decltype(Candidate), Type &, std::tuple_element_t<Index, std::tuple<Args...>>...>);
        data = &value_or_instance;
 
        fn = [](const void *payload, std::tuple<Args &&...> args) -> Ret {
            Type *curr = static_cast<Type *>(const_cast<std::conditional_t<std::is_const_v<Type>, const void *, void *>>(payload));
            // Ret(...) makes void(...) eat the return values to avoid errors
            return Ret(std::invoke(Candidate, *curr, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
        };
    }
 
    template<auto Candidate, typename Type, std::size_t... Index>
    void connect(Type *value_or_instance, std::index_sequence<Index...>) ENTT_NOEXCEPT {
        static_assert(std::is_invocable_r_v<Ret, decltype(Candidate), Type *, std::tuple_element_t<Index, std::tuple<Args...>>...>);
        data = value_or_instance;
 
        fn = [](const void *payload, std::tuple<Args &&...> args) -> Ret {
            Type *curr = static_cast<Type *>(const_cast<std::conditional_t<std::is_const_v<Type>, const void *, void *>>(payload));
            // Ret(...) makes void(...) eat the return values to avoid errors
            return Ret(std::invoke(Candidate, curr, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
        };
    }
 
public:
    using function_type = Ret(Args...);
 
    delegate() ENTT_NOEXCEPT
        : fn{nullptr}, data{nullptr}
    {}
 
    template<auto Function>
    delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
        : delegate{}
    {
        connect<Function>();
    }
 
    template<auto Candidate, typename Type>
    delegate(connect_arg_t<Candidate>, Type &value_or_instance) ENTT_NOEXCEPT
        : delegate{}
    {
        connect<Candidate>(value_or_instance);
    }
 
    template<auto Candidate, typename Type>
    delegate(connect_arg_t<Candidate>, Type *value_or_instance) ENTT_NOEXCEPT
        : delegate{}
    {
        connect<Candidate>(value_or_instance);
    }
 
    template<auto Function>
    void connect() ENTT_NOEXCEPT {
        connect<Function>(internal::index_sequence_for(internal::to_function_pointer_t<decltype(Function)>{}));
    }
 
    template<auto Candidate, typename Type>
    void connect(Type &value_or_instance) ENTT_NOEXCEPT {
        connect<Candidate>(value_or_instance, internal::index_sequence_for(internal::to_function_pointer_t<decltype(Candidate), Type *>{}));
    }
 
    template<auto Candidate, typename Type>
    void connect(Type *value_or_instance) ENTT_NOEXCEPT {
        connect<Candidate>(value_or_instance, internal::index_sequence_for(internal::to_function_pointer_t<decltype(Candidate), Type *>{}));
    }
 
    void reset() ENTT_NOEXCEPT {
        fn = nullptr;
        data = nullptr;
    }
 
    const void * instance() const ENTT_NOEXCEPT {
        return data;
    }
 
    Ret operator()(Args... args) const {
        ENTT_ASSERT(fn);
        return fn(data, std::forward_as_tuple(std::forward<Args>(args)...));
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        // no need to test also data
        return fn;
    }
 
    bool operator==(const delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
        return fn == other.fn && data == other.data;
    }
 
private:
    proto_fn_type *fn;
    const void *data;
};
 
 
template<typename Ret, typename... Args>
bool operator!=(const delegate<Ret(Args...)> &lhs, const delegate<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
template<auto Function>
delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
-> delegate<std::remove_pointer_t<internal::to_function_pointer_t<decltype(Function)>>>;
 
 
template<auto Candidate, typename Type>
delegate(connect_arg_t<Candidate>, Type &) ENTT_NOEXCEPT
-> delegate<std::remove_pointer_t<internal::to_function_pointer_t<decltype(Candidate), Type *>>>;
 
 
template<auto Candidate, typename Type>
delegate(connect_arg_t<Candidate>, Type *) ENTT_NOEXCEPT
-> delegate<std::remove_pointer_t<internal::to_function_pointer_t<decltype(Candidate), Type *>>>;
 
 
}
 
 
#endif // ENTT_SIGNAL_DELEGATE_HPP
 
// #include "../signal/sigh.hpp"
#ifndef ENTT_SIGNAL_SIGH_HPP
#define ENTT_SIGNAL_SIGH_HPP
 
 
#include <vector>
#include <utility>
#include <iterator>
#include <algorithm>
#include <functional>
#include <type_traits>
// #include "../config/config.h"
 
// #include "delegate.hpp"
 
// #include "fwd.hpp"
#ifndef ENTT_SIGNAL_FWD_HPP
#define ENTT_SIGNAL_FWD_HPP
 
 
namespace entt {
 
 
template<typename>
class delegate;
 
template<typename>
class sink;
 
template<typename>
class sigh;
 
 
}
 
 
#endif // ENTT_SIGNAL_FWD_HPP
 
 
 
namespace entt {
 
 
template<typename Function>
class sink;
 
 
template<typename Function>
class sigh;
 
 
template<typename Ret, typename... Args>
class sigh<Ret(Args...)> {
    friend class sink<Ret(Args...)>;
 
public:
    using size_type = std::size_t;
    using sink_type = entt::sink<Ret(Args...)>;
 
    template<typename Class>
    using instance_type = Class *;
 
    size_type size() const ENTT_NOEXCEPT {
        return calls.size();
    }
 
    bool empty() const ENTT_NOEXCEPT {
        return calls.empty();
    }
 
    void publish(Args... args) const {
        std::for_each(calls.cbegin(), calls.cend(), [&args...](auto &&call) {
            call(args...);
        });
    }
 
    template<typename Func>
    void collect(Func func, Args... args) const {
        for(auto &&call: calls) {
            if constexpr(std::is_void_v<Ret>) {
                if constexpr(std::is_invocable_r_v<bool, Func>) {
                    call(args...);
                    if(func()) { break; }
                } else {
                    call(args...);
                    func();
                }
            } else {
                if constexpr(std::is_invocable_r_v<bool, Func, Ret>) {
                    if(func(call(args...))) { break; }
                } else {
                    func(call(args...));
                }
            }
        }
    }
 
private:
    std::vector<delegate<Ret(Args...)>> calls;
};
 
 
class connection {
    template<typename>
    friend class sink;
 
    connection(delegate<void(void *)> fn, void *ref)
        : disconnect{fn}, signal{ref}
    {}
 
public:
    connection() = default;
 
    connection(const connection &) = default;
 
    connection(connection &&other)
        : connection{}
    {
        std::swap(disconnect, other.disconnect);
        std::swap(signal, other.signal);
    }
 
    connection & operator=(const connection &) = default;
 
    connection & operator=(connection &&other) {
        if(this != &other) {
            auto tmp{std::move(other)};
            disconnect = tmp.disconnect;
            signal = tmp.signal;
        }
 
        return *this;
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return static_cast<bool>(disconnect);
    }
 
    void release() {
        if(disconnect) {
            disconnect(signal);
            disconnect.reset();
        }
    }
 
private:
    delegate<void(void *)> disconnect;
    void *signal{};
};
 
 
struct scoped_connection: private connection {
    using connection::operator bool;
    using connection::release;
 
    scoped_connection() = default;
 
    scoped_connection(const connection &conn)
        : connection{conn}
    {}
 
    scoped_connection(const scoped_connection &) = delete;
 
    scoped_connection(scoped_connection &&) = default;
 
    ~scoped_connection() {
        connection::release();
    }
 
    scoped_connection & operator=(const scoped_connection &) = delete;
 
    scoped_connection & operator=(scoped_connection &&) = default;
 
    scoped_connection & operator=(const connection &other) {
        static_cast<connection &>(*this) = other;
        return *this;
    }
 
    scoped_connection & operator=(connection &&other) {
        static_cast<connection &>(*this) = std::move(other);
        return *this;
    }
};
 
 
template<typename Ret, typename... Args>
class sink<Ret(Args...)> {
    using signal_type = sigh<Ret(Args...)>;
    using difference_type = typename std::iterator_traits<typename decltype(signal_type::calls)::iterator>::difference_type;
 
    template<auto Candidate, typename Type>
    static void release(Type value_or_instance, void *signal) {
        sink{*static_cast<signal_type *>(signal)}.disconnect<Candidate>(value_or_instance);
    }
 
    template<auto Function>
    static void release(void *signal) {
        sink{*static_cast<signal_type *>(signal)}.disconnect<Function>();
    }
 
public:
    sink(sigh<Ret(Args...)> &ref) ENTT_NOEXCEPT
        : offset{},
          signal{&ref}
    {}
 
    bool empty() const ENTT_NOEXCEPT {
        return signal->calls.empty();
    }
 
    template<auto Function>
    sink before() {
        delegate<Ret(Args...)> call{};
        call.template connect<Function>();
 
        const auto &calls = signal->calls;
        const auto it = std::find(calls.cbegin(), calls.cend(), std::move(call));
 
        sink other{*this};
        other.offset = std::distance(it, calls.cend());
        return other;
    }
 
    template<auto Candidate, typename Type>
    sink before(Type &value_or_instance) {
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
 
        const auto &calls = signal->calls;
        const auto it = std::find(calls.cbegin(), calls.cend(), std::move(call));
 
        sink other{*this};
        other.offset = std::distance(it, calls.cend());
        return other;
    }
 
    template<auto Candidate, typename Type>
    sink before(Type *value_or_instance) {
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
 
        const auto &calls = signal->calls;
        const auto it = std::find(calls.cbegin(), calls.cend(), std::move(call));
 
        sink other{*this};
        other.offset = std::distance(it, calls.cend());
        return other;
    }
 
    template<typename Type>
    sink before(Type &value_or_instance) {
        return before(&value_or_instance);
    }
 
    template<typename Type>
    sink before(Type *value_or_instance) {
        sink other{*this};
 
        if(value_or_instance) {
            const auto &calls = signal->calls;
            const auto it = std::find_if(calls.cbegin(), calls.cend(), [value_or_instance](const auto &delegate) {
                return delegate.instance() == value_or_instance;
            });
 
            other.offset = std::distance(it, calls.cend());
        }
 
        return other;
    }
 
    sink before() {
        sink other{*this};
        other.offset = signal->calls.size();
        return other;
    }
 
    template<auto Function>
    connection connect() {
        disconnect<Function>();
 
        delegate<Ret(Args...)> call{};
        call.template connect<Function>();
        signal->calls.insert(signal->calls.end() - offset, std::move(call));
 
        delegate<void(void *)> conn{};
        conn.template connect<&release<Function>>();
        return { std::move(conn), signal };
    }
 
    template<auto Candidate, typename Type>
    connection connect(Type &value_or_instance) {
        disconnect<Candidate>(value_or_instance);
 
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
        signal->calls.insert(signal->calls.end() - offset, std::move(call));
 
        delegate<void(void *)> conn{};
        conn.template connect<&release<Candidate, Type &>>(value_or_instance);
        return { std::move(conn), signal };
    }
 
    template<auto Candidate, typename Type>
    connection connect(Type *value_or_instance) {
        disconnect<Candidate>(value_or_instance);
 
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
        signal->calls.insert(signal->calls.end() - offset, std::move(call));
 
        delegate<void(void *)> conn{};
        conn.template connect<&release<Candidate, Type *>>(value_or_instance);
        return { std::move(conn), signal };
    }
 
    template<auto Function>
    void disconnect() {
        auto &calls = signal->calls;
        delegate<Ret(Args...)> call{};
        call.template connect<Function>();
        calls.erase(std::remove(calls.begin(), calls.end(), std::move(call)), calls.end());
    }
 
    template<auto Candidate, typename Type>
    void disconnect(Type &value_or_instance) {
        auto &calls = signal->calls;
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
        calls.erase(std::remove(calls.begin(), calls.end(), std::move(call)), calls.end());
    }
 
    template<auto Candidate, typename Type>
    void disconnect(Type *value_or_instance) {
        auto &calls = signal->calls;
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
        calls.erase(std::remove(calls.begin(), calls.end(), std::move(call)), calls.end());
    }
 
    template<typename Type>
    void disconnect(Type &value_or_instance) {
        disconnect(&value_or_instance);
    }
 
    template<typename Type>
    void disconnect(Type *value_or_instance) {
        if(value_or_instance) {
            auto &calls = signal->calls;
            calls.erase(std::remove_if(calls.begin(), calls.end(), [value_or_instance](const auto &delegate) {
                return delegate.instance() == value_or_instance;
            }), calls.end());
        }
    }
 
    void disconnect() {
        signal->calls.clear();
    }
 
private:
    difference_type offset;
    signal_type *signal;
};
 
 
template<typename Ret, typename... Args>
sink(sigh<Ret(Args...)> &) ENTT_NOEXCEPT -> sink<Ret(Args...)>;
 
 
}
 
 
#endif // ENTT_SIGNAL_SIGH_HPP
 
// #include "runtime_view.hpp"
#ifndef ENTT_ENTITY_RUNTIME_VIEW_HPP
#define ENTT_ENTITY_RUNTIME_VIEW_HPP
 
 
#include <iterator>
#include <cassert>
#include <vector>
#include <utility>
#include <algorithm>
#include <type_traits>
// #include "../config/config.h"
 
// #include "sparse_set.hpp"
#ifndef ENTT_ENTITY_SPARSE_SET_HPP
#define ENTT_ENTITY_SPARSE_SET_HPP
 
 
#include <algorithm>
#include <iterator>
#include <utility>
#include <vector>
#include <memory>
#include <cstddef>
#include <numeric>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/algorithm.hpp"
 
// #include "entity.hpp"
#ifndef ENTT_ENTITY_ENTITY_HPP
#define ENTT_ENTITY_ENTITY_HPP
 
 
#include <cstdint>
#include <type_traits>
// #include "../config/config.h"
 
 
 
namespace entt {
 
 
template<typename>
struct entt_traits;
 
 
template<>
struct entt_traits<std::uint16_t> {
    using entity_type = std::uint16_t;
    using version_type = std::uint8_t;
    using difference_type = std::int32_t;
 
    static constexpr std::uint16_t entity_mask = 0xFFF;
    static constexpr std::uint16_t version_mask = 0xF;
    static constexpr auto entity_shift = 12;
};
 
 
template<>
struct entt_traits<std::uint32_t> {
    using entity_type = std::uint32_t;
    using version_type = std::uint16_t;
    using difference_type = std::int64_t;
 
    static constexpr std::uint32_t entity_mask = 0xFFFFF;
    static constexpr std::uint32_t version_mask = 0xFFF;
    static constexpr auto entity_shift = 20;
};
 
 
template<>
struct entt_traits<std::uint64_t> {
    using entity_type = std::uint64_t;
    using version_type = std::uint32_t;
    using difference_type = std::int64_t;
 
    static constexpr std::uint64_t entity_mask = 0xFFFFFFFF;
    static constexpr std::uint64_t version_mask = 0xFFFFFFFF;
    static constexpr auto entity_shift = 32;
};
 
 
namespace internal {
 
 
class null {
    template<typename Entity>
    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
public:
    template<typename Entity>
    constexpr operator Entity() const ENTT_NOEXCEPT {
        return Entity{traits_type<Entity>::entity_mask};
    }
 
    constexpr bool operator==(null) const ENTT_NOEXCEPT {
        return true;
    }
 
    constexpr bool operator!=(null) const ENTT_NOEXCEPT {
        return false;
    }
 
    template<typename Entity>
    constexpr bool operator==(const Entity entity) const ENTT_NOEXCEPT {
        return (to_integer(entity) & traits_type<Entity>::entity_mask) == to_integer(static_cast<Entity>(*this));
    }
 
    template<typename Entity>
    constexpr bool operator!=(const Entity entity) const ENTT_NOEXCEPT {
        return !(entity == *this);
    }
};
 
 
template<typename Entity>
constexpr bool operator==(const Entity entity, null other) ENTT_NOEXCEPT {
    return other == entity;
}
 
 
template<typename Entity>
constexpr bool operator!=(const Entity entity, null other) ENTT_NOEXCEPT {
    return other != entity;
}
 
 
}
 
 
constexpr auto null = internal::null{};
 
 
}
 
 
#endif // ENTT_ENTITY_ENTITY_HPP
 
// #include "fwd.hpp"
#ifndef ENTT_ENTITY_FWD_HPP
#define ENTT_ENTITY_FWD_HPP
 
 
// #include "../config/config.h"
 
// #include "../core/type_traits.hpp"
 
 
 
namespace entt {
 
template <typename>
class basic_registry;
 
template<typename...>
class basic_view;
 
template<typename>
class basic_runtime_view;
 
template<typename...>
class basic_group;
 
template<typename>
class basic_observer;
 
template <typename>
struct basic_actor;
 
template<typename>
class basic_snapshot;
 
template<typename>
class basic_snapshot_loader;
 
template<typename>
class basic_continuous_loader;
 
ENTT_OPAQUE_TYPE(entity, ENTT_ID_TYPE);
 
ENTT_OPAQUE_TYPE(component, ENTT_ID_TYPE);
 
using registry = basic_registry<entity>;
 
using observer = basic_observer<entity>;
 
using actor = basic_actor<entity>;
 
using snapshot = basic_snapshot<entity>;
 
using snapshot_loader = basic_snapshot_loader<entity>;
 
using continuous_loader = basic_continuous_loader<entity>;
 
template<typename... Types>
using view = basic_view<entity, Types...>;
 
using runtime_view = basic_runtime_view<entity>;
 
template<typename... Types>
using group = basic_group<entity, Types...>;
 
 
}
 
 
#endif // ENTT_ENTITY_FWD_HPP
 
 
 
namespace entt {
 
 
template<typename Entity>
class sparse_set {
    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
    static_assert(ENTT_PAGE_SIZE && ((ENTT_PAGE_SIZE & (ENTT_PAGE_SIZE - 1)) == 0));
    static constexpr auto entt_per_page = ENTT_PAGE_SIZE / sizeof(typename traits_type::entity_type);
 
    class iterator {
        friend class sparse_set<Entity>;
 
        using direct_type = const std::vector<Entity>;
        using index_type = typename traits_type::difference_type;
 
        iterator(direct_type *ref, const index_type idx) ENTT_NOEXCEPT
            : direct{ref}, index{idx}
        {}
 
    public:
        using difference_type = index_type;
        using value_type = Entity;
        using pointer = const value_type *;
        using reference = const value_type &;
        using iterator_category = std::random_access_iterator_tag;
 
        iterator() ENTT_NOEXCEPT = default;
 
        iterator & operator++() ENTT_NOEXCEPT {
            return --index, *this;
        }
 
        iterator operator++(int) ENTT_NOEXCEPT {
            iterator orig = *this;
            return ++(*this), orig;
        }
 
        iterator & operator--() ENTT_NOEXCEPT {
            return ++index, *this;
        }
 
        iterator operator--(int) ENTT_NOEXCEPT {
            iterator orig = *this;
            return --(*this), orig;
        }
 
        iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
            index -= value;
            return *this;
        }
 
        iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
            return iterator{direct, index-value};
        }
 
        iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
            return (*this += -value);
        }
 
        iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
            return (*this + -value);
        }
 
        difference_type operator-(const iterator &other) const ENTT_NOEXCEPT {
            return other.index - index;
        }
 
        reference operator[](const difference_type value) const ENTT_NOEXCEPT {
            const auto pos = size_type(index-value-1);
            return (*direct)[pos];
        }
 
        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
            return other.index == index;
        }
 
        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this == other);
        }
 
        bool operator<(const iterator &other) const ENTT_NOEXCEPT {
            return index > other.index;
        }
 
        bool operator>(const iterator &other) const ENTT_NOEXCEPT {
            return index < other.index;
        }
 
        bool operator<=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this > other);
        }
 
        bool operator>=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this < other);
        }
 
        pointer operator->() const ENTT_NOEXCEPT {
            const auto pos = size_type(index-1);
            return &(*direct)[pos];
        }
 
        reference operator*() const ENTT_NOEXCEPT {
            return *operator->();
        }
 
    private:
        direct_type *direct;
        index_type index;
    };
 
    void assure(const std::size_t page) {
        if(!(page < reverse.size())) {
            reverse.resize(page+1);
        }
 
        if(!reverse[page]) {
            reverse[page] = std::make_unique<entity_type[]>(entt_per_page);
            // null is safe in all cases for our purposes
            std::fill_n(reverse[page].get(), entt_per_page, null);
        }
    }
 
    auto map(const Entity entt) const ENTT_NOEXCEPT {
        const auto identifier = to_integer(entt) & traits_type::entity_mask;
        const auto page = size_type(identifier / entt_per_page);
        const auto offset = size_type(identifier & (entt_per_page - 1));
        return std::make_pair(page, offset);
    }
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator_type = iterator;
 
    sparse_set() = default;
 
    sparse_set(const sparse_set &other)
        : reverse{},
          direct{other.direct}
    {
        for(size_type pos{}, last = other.reverse.size(); pos < last; ++pos) {
            if(other.reverse[pos]) {
                assure(pos);
                std::copy_n(other.reverse[pos].get(), entt_per_page, reverse[pos].get());
            }
        }
    }
 
    sparse_set(sparse_set &&) = default;
 
    virtual ~sparse_set() ENTT_NOEXCEPT = default;
 
    sparse_set & operator=(const sparse_set &other) {
        if(&other != this) {
            auto tmp{other};
            *this = std::move(tmp);
        }
 
        return *this;
    }
 
    sparse_set & operator=(sparse_set &&) = default;
 
    void reserve(const size_type cap) {
        direct.reserve(cap);
    }
 
    size_type capacity() const ENTT_NOEXCEPT {
        return direct.capacity();
    }
 
    void shrink_to_fit() {
        // conservative approach
        if(direct.empty()) {
            reverse.clear();
        }
 
        reverse.shrink_to_fit();
        direct.shrink_to_fit();
    }
 
    size_type extent() const ENTT_NOEXCEPT {
        return reverse.size() * entt_per_page;
    }
 
    size_type size() const ENTT_NOEXCEPT {
        return direct.size();
    }
 
    bool empty() const ENTT_NOEXCEPT {
        return direct.empty();
    }
 
    const entity_type * data() const ENTT_NOEXCEPT {
        return direct.data();
    }
 
    iterator_type begin() const ENTT_NOEXCEPT {
        const typename traits_type::difference_type pos = direct.size();
        return iterator_type{&direct, pos};
    }
 
    iterator_type end() const ENTT_NOEXCEPT {
        return iterator_type{&direct, {}};
    }
 
    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
        return has(entt) ? --(end() - index(entt)) : end();
    }
 
    bool has(const entity_type entt) const ENTT_NOEXCEPT {
        auto [page, offset] = map(entt);
        // testing against null permits to avoid accessing the direct vector
        return (page < reverse.size() && reverse[page] && reverse[page][offset] != null);
    }
 
    size_type index(const entity_type entt) const ENTT_NOEXCEPT {
        ENTT_ASSERT(has(entt));
        auto [page, offset] = map(entt);
        return size_type(reverse[page][offset]);
    }
 
    void construct(const entity_type entt) {
        ENTT_ASSERT(!has(entt));
        auto [page, offset] = map(entt);
        assure(page);
        reverse[page][offset] = entity_type(direct.size());
        direct.push_back(entt);
    }
 
    template<typename It>
    void batch(It first, It last) {
        std::for_each(first, last, [this, next = direct.size()](const auto entt) mutable {
            ENTT_ASSERT(!has(entt));
            auto [page, offset] = map(entt);
            assure(page);
            reverse[page][offset] = entity_type(next++);
        });
 
        direct.insert(direct.end(), first, last);
    }
 
    void destroy(const entity_type entt) {
        ENTT_ASSERT(has(entt));
        auto [from_page, from_offset] = map(entt);
        auto [to_page, to_offset] = map(direct.back());
        direct[size_type(reverse[from_page][from_offset])] = entity_type(direct.back());
        reverse[to_page][to_offset] = reverse[from_page][from_offset];
        reverse[from_page][from_offset] = null;
        direct.pop_back();
    }
 
    virtual void swap(const entity_type lhs, const entity_type rhs) ENTT_NOEXCEPT {
        auto [src_page, src_offset] = map(lhs);
        auto [dst_page, dst_offset] = map(rhs);
        auto &from = reverse[src_page][src_offset];
        auto &to = reverse[dst_page][dst_offset];
        std::swap(direct[size_type(from)], direct[size_type(to)]);
        std::swap(from, to);
    }
 
    template<typename Compare, typename Sort = std_sort, typename... Args>
    void sort(iterator_type first, iterator_type last, Compare compare, Sort algo = Sort{}, Args &&... args) {
        ENTT_ASSERT(!(last < first));
        ENTT_ASSERT(!(last > end()));
 
        const auto length = std::distance(first, last);
        const auto skip = std::distance(last, end());
        const auto to = direct.rend() - skip;
        const auto from = to - length;
 
        algo(from, to, std::move(compare), std::forward<Args>(args)...);
 
        for(size_type pos = skip, end = skip+length; pos < end; ++pos) {
            auto [page, offset] = map(direct[pos]);
            reverse[page][offset] = entity_type(pos);
        }
    }
 
    template<typename Apply, typename Compare, typename Sort = std_sort, typename... Args>
    void arrange(iterator_type first, iterator_type last, Apply apply, Compare compare, Sort algo = Sort{}, Args &&... args) {
        ENTT_ASSERT(!(last < first));
        ENTT_ASSERT(!(last > end()));
 
        const auto length = std::distance(first, last);
        const auto skip = std::distance(last, end());
        const auto to = direct.rend() - skip;
        const auto from = to - length;
 
        algo(from, to, std::move(compare), std::forward<Args>(args)...);
 
        for(size_type pos = skip, end = skip+length; pos < end; ++pos) {
            auto curr = pos;
            auto next = index(direct[curr]);
 
            while(curr != next) {
                apply(direct[curr], direct[next]);
                auto [page, offset] = map(direct[curr]);
                reverse[page][offset] = entity_type(curr);
 
                curr = next;
                next = index(direct[curr]);
            }
        }
    }
 
    void respect(const sparse_set &other) ENTT_NOEXCEPT {
        const auto to = other.end();
        auto from = other.begin();
 
        size_type pos = direct.size() - 1;
 
        while(pos && from != to) {
            if(has(*from)) {
                if(*from != direct[pos]) {
                    swap(direct[pos], *from);
                }
 
                --pos;
            }
 
            ++from;
        }
    }
 
    void reset() {
        reverse.clear();
        direct.clear();
    }
 
private:
    std::vector<std::unique_ptr<entity_type[]>> reverse;
    std::vector<entity_type> direct;
};
 
 
}
 
 
#endif // ENTT_ENTITY_SPARSE_SET_HPP
 
// #include "entity.hpp"
 
// #include "fwd.hpp"
 
 
 
namespace entt {
 
 
template<typename Entity>
class basic_runtime_view {
    friend class basic_registry<Entity>;
 
    using underlying_iterator_type = typename sparse_set<Entity>::iterator_type;
 
    class iterator {
        friend class basic_runtime_view<Entity>;
 
        iterator(underlying_iterator_type first, underlying_iterator_type last, const sparse_set<Entity> * const *others, const sparse_set<Entity> * const *length) ENTT_NOEXCEPT
            : begin{first},
              end{last},
              from{others},
              to{length}
        {
            if(begin != end && !valid()) {
                ++(*this);
            }
        }
 
        bool valid() const ENTT_NOEXCEPT {
            return std::all_of(from, to, [entt = *begin](const auto *view) {
                return view->has(entt);
            });
        }
 
    public:
        using difference_type = typename underlying_iterator_type::difference_type;
        using value_type = typename underlying_iterator_type::value_type;
        using pointer = typename underlying_iterator_type::pointer;
        using reference = typename underlying_iterator_type::reference;
        using iterator_category = std::forward_iterator_tag;
 
        iterator() ENTT_NOEXCEPT = default;
 
        iterator & operator++() ENTT_NOEXCEPT {
            return (++begin != end && !valid()) ? ++(*this) : *this;
        }
 
        iterator operator++(int) ENTT_NOEXCEPT {
            iterator orig = *this;
            return ++(*this), orig;
        }
 
        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
            return other.begin == begin;
        }
 
        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this == other);
        }
 
        pointer operator->() const ENTT_NOEXCEPT {
            return begin.operator->();
        }
 
        reference operator*() const ENTT_NOEXCEPT {
            return *operator->();
        }
 
    private:
        underlying_iterator_type begin;
        underlying_iterator_type end;
        const sparse_set<Entity> * const *from;
        const sparse_set<Entity> * const *to;
    };
 
    basic_runtime_view(std::vector<const sparse_set<Entity> *> others) ENTT_NOEXCEPT
        : pools{std::move(others)}
    {
        const auto it = std::min_element(pools.begin(), pools.end(), [](const auto *lhs, const auto *rhs) {
            return (!lhs && rhs) || (lhs && rhs && lhs->size() < rhs->size());
        });
 
        // brings the best candidate (if any) on front of the vector
        std::rotate(pools.begin(), it, pools.end());
    }
 
    bool valid() const ENTT_NOEXCEPT {
        return !pools.empty() && pools.front();
    }
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator_type = iterator;
 
    size_type size() const ENTT_NOEXCEPT {
        return valid() ? pools.front()->size() : size_type{};
    }
 
    bool empty() const ENTT_NOEXCEPT {
        return !valid() || pools.front()->empty();
    }
 
    iterator_type begin() const ENTT_NOEXCEPT {
        iterator_type it{};
 
        if(valid()) {
            const auto &pool = *pools.front();
            const auto * const *data = pools.data();
            it = { pool.begin(), pool.end(), data + 1, data + pools.size() };
        }
 
        return it;
    }
 
    iterator_type end() const ENTT_NOEXCEPT {
        iterator_type it{};
 
        if(valid()) {
            const auto &pool = *pools.front();
            it = { pool.end(), pool.end(), nullptr, nullptr };
        }
 
        return it;
    }
 
    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
        return valid() && std::all_of(pools.cbegin(), pools.cend(), [entt](const auto *view) {
            return view->find(entt) != view->end();
        });
    }
 
    template<typename Func>
    void each(Func func) const {
        std::for_each(begin(), end(), func);
    }
 
private:
    std::vector<const sparse_set<Entity> *> pools;
};
 
 
}
 
 
#endif // ENTT_ENTITY_RUNTIME_VIEW_HPP
 
// #include "sparse_set.hpp"
 
// #include "snapshot.hpp"
#ifndef ENTT_ENTITY_SNAPSHOT_HPP
#define ENTT_ENTITY_SNAPSHOT_HPP
 
 
#include <array>
#include <cstddef>
#include <utility>
#include <iterator>
#include <type_traits>
#include <unordered_map>
// #include "../config/config.h"
 
// #include "entity.hpp"
 
// #include "fwd.hpp"
 
 
 
namespace entt {
 
 
template<typename Entity>
class basic_snapshot {
    friend class basic_registry<Entity>;
 
    using follow_fn_type = Entity(const basic_registry<Entity> &, const Entity);
    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
    basic_snapshot(const basic_registry<Entity> *source, Entity init, follow_fn_type *fn) ENTT_NOEXCEPT
        : reg{source},
          seed{init},
          follow{fn}
    {}
 
    template<typename Component, typename Archive, typename It>
    void get(Archive &archive, std::size_t sz, It first, It last) const {
        archive(typename traits_type::entity_type(sz));
 
        while(first != last) {
            const auto entt = *(first++);
 
            if(reg->template has<Component>(entt)) {
                if constexpr(std::is_empty_v<Component>) {
                    archive(entt);
                } else {
                    archive(entt, reg->template get<Component>(entt));
                }
            }
        }
    }
 
    template<typename... Component, typename Archive, typename It, std::size_t... Indexes>
    void component(Archive &archive, It first, It last, std::index_sequence<Indexes...>) const {
        std::array<std::size_t, sizeof...(Indexes)> size{};
        auto begin = first;
 
        while(begin != last) {
            const auto entt = *(begin++);
            ((reg->template has<Component>(entt) ? ++size[Indexes] : size[Indexes]), ...);
        }
 
        (get<Component>(archive, size[Indexes], first, last), ...);
    }
 
public:
    basic_snapshot(basic_snapshot &&) = default;
 
    basic_snapshot & operator=(basic_snapshot &&) = default;
 
    template<typename Archive>
    const basic_snapshot & entities(Archive &archive) const {
        archive(typename traits_type::entity_type(reg->alive()));
        reg->each([&archive](const auto entt) { archive(entt); });
        return *this;
    }
 
    template<typename Archive>
    const basic_snapshot & destroyed(Archive &archive) const {
        auto size = reg->size() - reg->alive();
        archive(typename traits_type::entity_type(size));
 
        if(size) {
            auto curr = seed;
            archive(curr);
 
            for(--size; size; --size) {
                curr = follow(*reg, curr);
                archive(curr);
            }
        }
 
        return *this;
    }
 
    template<typename... Component, typename Archive>
    const basic_snapshot & component(Archive &archive) const {
        (component<Component>(archive, reg->template data<Component>(), reg->template data<Component>() + reg->template size<Component>()), ...);
        return *this;
    }
 
    template<typename... Component, typename Archive, typename It>
    const basic_snapshot & component(Archive &archive, It first, It last) const {
        component<Component...>(archive, first, last, std::index_sequence_for<Component...>{});
        return *this;
    }
 
private:
    const basic_registry<Entity> *reg;
    const Entity seed;
    follow_fn_type *follow;
};
 
 
template<typename Entity>
class basic_snapshot_loader {
    friend class basic_registry<Entity>;
 
    using force_fn_type = void(basic_registry<Entity> &, const Entity, const bool);
    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
    basic_snapshot_loader(basic_registry<Entity> *source, force_fn_type *fn) ENTT_NOEXCEPT
        : reg{source},
          force{fn}
    {
        // to restore a snapshot as a whole requires a clean registry
        ENTT_ASSERT(reg->empty());
    }
 
    template<typename Archive>
    void assure(Archive &archive, bool discard) const {
        typename traits_type::entity_type length{};
        archive(length);
 
        while(length--) {
            Entity entt{};
            archive(entt);
            force(*reg, entt, discard);
        }
    }
 
    template<typename Type, typename Archive, typename... Args>
    void assign(Archive &archive, Args... args) const {
        typename traits_type::entity_type length{};
        archive(length);
 
        while(length--) {
            static constexpr auto discard = false;
            Entity entt{};
 
            if constexpr(std::is_empty_v<Type>) {
                archive(entt);
                force(*reg, entt, discard);
                reg->template assign<Type>(args..., entt);
            } else {
                Type instance{};
                archive(entt, instance);
                force(*reg, entt, discard);
                reg->template assign<Type>(args..., entt, std::as_const(instance));
            }
        }
    }
 
public:
    basic_snapshot_loader(basic_snapshot_loader &&) = default;
 
    basic_snapshot_loader & operator=(basic_snapshot_loader &&) = default;
 
    template<typename Archive>
    const basic_snapshot_loader & entities(Archive &archive) const {
        static constexpr auto discard = false;
        assure(archive, discard);
        return *this;
    }
 
    template<typename Archive>
    const basic_snapshot_loader & destroyed(Archive &archive) const {
        static constexpr auto discard = true;
        assure(archive, discard);
        return *this;
    }
 
    template<typename... Component, typename Archive>
    const basic_snapshot_loader & component(Archive &archive) const {
        (assign<Component>(archive), ...);
        return *this;
    }
 
    const basic_snapshot_loader & orphans() const {
        reg->orphans([this](const auto entt) {
            reg->destroy(entt);
        });
 
        return *this;
    }
 
private:
    basic_registry<Entity> *reg;
    force_fn_type *force;
};
 
 
template<typename Entity>
class basic_continuous_loader {
    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
    void destroy(Entity entt) {
        const auto it = remloc.find(entt);
 
        if(it == remloc.cend()) {
            const auto local = reg->create();
            remloc.emplace(entt, std::make_pair(local, true));
            reg->destroy(local);
        }
    }
 
    void restore(Entity entt) {
        const auto it = remloc.find(entt);
 
        if(it == remloc.cend()) {
            const auto local = reg->create();
            remloc.emplace(entt, std::make_pair(local, true));
        } else {
            remloc[entt].first = reg->valid(remloc[entt].first) ? remloc[entt].first : reg->create();
            // set the dirty flag
            remloc[entt].second = true;
        }
    }
 
    template<typename Container>
    auto update(int, Container &container)
    -> decltype(typename Container::mapped_type{}, void()) {
        // map like container
        Container other;
 
        for(auto &&pair: container) {
            using first_type = std::remove_const_t<typename std::decay_t<decltype(pair)>::first_type>;
            using second_type = typename std::decay_t<decltype(pair)>::second_type;
 
            if constexpr(std::is_same_v<first_type, Entity> && std::is_same_v<second_type, Entity>) {
                other.emplace(map(pair.first), map(pair.second));
            } else if constexpr(std::is_same_v<first_type, Entity>) {
                other.emplace(map(pair.first), std::move(pair.second));
            } else {
                static_assert(std::is_same_v<second_type, Entity>);
                other.emplace(std::move(pair.first), map(pair.second));
            }
        }
 
        std::swap(container, other);
    }
 
    template<typename Container>
    auto update(char, Container &container)
    -> decltype(typename Container::value_type{}, void()) {
        // vector like container
        static_assert(std::is_same_v<typename Container::value_type, Entity>);
 
        for(auto &&entt: container) {
            entt = map(entt);
        }
    }
 
    template<typename Other, typename Type, typename Member>
    void update(Other &instance, Member Type:: *member) {
        if constexpr(!std::is_same_v<Other, Type>) {
            return;
        } else if constexpr(std::is_same_v<Member, Entity>) {
            instance.*member = map(instance.*member);
        } else {
            // maybe a container? let's try...
            update(0, instance.*member);
        }
    }
 
    template<typename Archive>
    void assure(Archive &archive, void(basic_continuous_loader:: *member)(Entity)) {
        typename traits_type::entity_type length{};
        archive(length);
 
        while(length--) {
            Entity entt{};
            archive(entt);
            (this->*member)(entt);
        }
    }
 
    template<typename Component>
    void reset() {
        for(auto &&ref: remloc) {
            const auto local = ref.second.first;
 
            if(reg->valid(local)) {
                reg->template reset<Component>(local);
            }
        }
    }
 
    template<typename Other, typename Archive, typename... Type, typename... Member>
    void assign(Archive &archive, [[maybe_unused]] Member Type:: *... member) {
        typename traits_type::entity_type length{};
        archive(length);
 
        while(length--) {
            Entity entt{};
 
            if constexpr(std::is_empty_v<Other>) {
                archive(entt);
                restore(entt);
                reg->template assign_or_replace<Other>(map(entt));
            } else {
                Other instance{};
                archive(entt, instance);
                (update(instance, member), ...);
                restore(entt);
                reg->template assign_or_replace<Other>(map(entt), std::as_const(instance));
            }
        }
    }
 
public:
    using entity_type = Entity;
 
    basic_continuous_loader(basic_registry<entity_type> &source) ENTT_NOEXCEPT
        : reg{&source}
    {}
 
    basic_continuous_loader(basic_continuous_loader &&) = default;
 
    basic_continuous_loader & operator=(basic_continuous_loader &&) = default;
 
    template<typename Archive>
    basic_continuous_loader & entities(Archive &archive) {
        assure(archive, &basic_continuous_loader::restore);
        return *this;
    }
 
    template<typename Archive>
    basic_continuous_loader & destroyed(Archive &archive) {
        assure(archive, &basic_continuous_loader::destroy);
        return *this;
    }
 
    template<typename... Component, typename Archive, typename... Type, typename... Member>
    basic_continuous_loader & component(Archive &archive, Member Type:: *... member) {
        (reset<Component>(), ...);
        (assign<Component>(archive, member...), ...);
        return *this;
    }
 
    basic_continuous_loader & shrink() {
        auto it = remloc.begin();
 
        while(it != remloc.cend()) {
            const auto local = it->second.first;
            bool &dirty = it->second.second;
 
            if(dirty) {
                dirty = false;
                ++it;
            } else {
                if(reg->valid(local)) {
                    reg->destroy(local);
                }
 
                it = remloc.erase(it);
            }
        }
 
        return *this;
    }
 
    basic_continuous_loader & orphans() {
        reg->orphans([this](const auto entt) {
            reg->destroy(entt);
        });
 
        return *this;
    }
 
    bool has(entity_type entt) const ENTT_NOEXCEPT {
        return (remloc.find(entt) != remloc.cend());
    }
 
    entity_type map(entity_type entt) const ENTT_NOEXCEPT {
        const auto it = remloc.find(entt);
        entity_type other = null;
 
        if(it != remloc.cend()) {
            other = it->second.first;
        }
 
        return other;
    }
 
private:
    std::unordered_map<entity_type, std::pair<entity_type, bool>> remloc;
    basic_registry<entity_type> *reg;
};
 
 
}
 
 
#endif // ENTT_ENTITY_SNAPSHOT_HPP
 
// #include "storage.hpp"
#ifndef ENTT_ENTITY_STORAGE_HPP
#define ENTT_ENTITY_STORAGE_HPP
 
 
#include <algorithm>
#include <iterator>
#include <numeric>
#include <utility>
#include <vector>
#include <cstddef>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/algorithm.hpp"
 
// #include "sparse_set.hpp"
 
// #include "entity.hpp"
 
 
 
namespace entt {
 
 
template<typename Entity, typename Type, typename = std::void_t<>>
class basic_storage: public sparse_set<Entity> {
    using underlying_type = sparse_set<Entity>;
    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
    template<bool Const>
    class iterator {
        friend class basic_storage<Entity, Type>;
 
        using instance_type = std::conditional_t<Const, const std::vector<Type>, std::vector<Type>>;
        using index_type = typename traits_type::difference_type;
 
        iterator(instance_type *ref, const index_type idx) ENTT_NOEXCEPT
            : instances{ref}, index{idx}
        {}
 
    public:
        using difference_type = index_type;
        using value_type = Type;
        using pointer = std::conditional_t<Const, const value_type *, value_type *>;
        using reference = std::conditional_t<Const, const value_type &, value_type &>;
        using iterator_category = std::random_access_iterator_tag;
 
        iterator() ENTT_NOEXCEPT = default;
 
        iterator & operator++() ENTT_NOEXCEPT {
            return --index, *this;
        }
 
        iterator operator++(int) ENTT_NOEXCEPT {
            iterator orig = *this;
            return ++(*this), orig;
        }
 
        iterator & operator--() ENTT_NOEXCEPT {
            return ++index, *this;
        }
 
        iterator operator--(int) ENTT_NOEXCEPT {
            iterator orig = *this;
            return --(*this), orig;
        }
 
        iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
            index -= value;
            return *this;
        }
 
        iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
            return iterator{instances, index-value};
        }
 
        iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
            return (*this += -value);
        }
 
        iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
            return (*this + -value);
        }
 
        difference_type operator-(const iterator &other) const ENTT_NOEXCEPT {
            return other.index - index;
        }
 
        reference operator[](const difference_type value) const ENTT_NOEXCEPT {
            const auto pos = size_type(index-value-1);
            return (*instances)[pos];
        }
 
        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
            return other.index == index;
        }
 
        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this == other);
        }
 
        bool operator<(const iterator &other) const ENTT_NOEXCEPT {
            return index > other.index;
        }
 
        bool operator>(const iterator &other) const ENTT_NOEXCEPT {
            return index < other.index;
        }
 
        bool operator<=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this > other);
        }
 
        bool operator>=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this < other);
        }
 
        pointer operator->() const ENTT_NOEXCEPT {
            const auto pos = size_type(index-1);
            return &(*instances)[pos];
        }
 
        reference operator*() const ENTT_NOEXCEPT {
            return *operator->();
        }
 
    private:
        instance_type *instances;
        index_type index;
    };
 
public:
    using object_type = Type;
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator_type = iterator<false>;
    using const_iterator_type = iterator<true>;
 
    void reserve(const size_type cap) {
        underlying_type::reserve(cap);
        instances.reserve(cap);
    }
 
    void shrink_to_fit() {
        underlying_type::shrink_to_fit();
        instances.shrink_to_fit();
    }
 
    const object_type * raw() const ENTT_NOEXCEPT {
        return instances.data();
    }
 
    object_type * raw() ENTT_NOEXCEPT {
        return const_cast<object_type *>(std::as_const(*this).raw());
    }
 
    const_iterator_type cbegin() const ENTT_NOEXCEPT {
        const typename traits_type::difference_type pos = underlying_type::size();
        return const_iterator_type{&instances, pos};
    }
 
    const_iterator_type begin() const ENTT_NOEXCEPT {
        return cbegin();
    }
 
    iterator_type begin() ENTT_NOEXCEPT {
        const typename traits_type::difference_type pos = underlying_type::size();
        return iterator_type{&instances, pos};
    }
 
    const_iterator_type cend() const ENTT_NOEXCEPT {
        return const_iterator_type{&instances, {}};
    }
 
    const_iterator_type end() const ENTT_NOEXCEPT {
        return cend();
    }
 
    iterator_type end() ENTT_NOEXCEPT {
        return iterator_type{&instances, {}};
    }
 
    const object_type & get(const entity_type entt) const ENTT_NOEXCEPT {
        return instances[underlying_type::index(entt)];
    }
 
    object_type & get(const entity_type entt) ENTT_NOEXCEPT {
        return const_cast<object_type &>(std::as_const(*this).get(entt));
    }
 
    const object_type * try_get(const entity_type entt) const ENTT_NOEXCEPT {
        return underlying_type::has(entt) ? (instances.data() + underlying_type::index(entt)) : nullptr;
    }
 
    object_type * try_get(const entity_type entt) ENTT_NOEXCEPT {
        return const_cast<object_type *>(std::as_const(*this).try_get(entt));
    }
 
    template<typename... Args>
    object_type & construct(const entity_type entt, Args &&... args) {
        if constexpr(std::is_aggregate_v<object_type>) {
            instances.emplace_back(Type{std::forward<Args>(args)...});
        } else {
            instances.emplace_back(std::forward<Args>(args)...);
        }
 
        // entity goes after component in case constructor throws
        underlying_type::construct(entt);
        return instances.back();
    }
 
    template<typename It, typename... Args>
    iterator_type batch(It first, It last, Args &&... args) {
        if constexpr(sizeof...(Args) == 0) {
            instances.resize(instances.size() + std::distance(first, last));
        } else {
            instances.resize(instances.size() + std::distance(first, last), Type{std::forward<Args>(args)...});
        }
 
        // entity goes after component in case constructor throws
        underlying_type::batch(first, last);
        return begin();
    }
 
    void destroy(const entity_type entt) {
        auto other = std::move(instances.back());
        instances[underlying_type::index(entt)] = std::move(other);
        instances.pop_back();
        underlying_type::destroy(entt);
    }
 
    void swap(const entity_type lhs, const entity_type rhs) ENTT_NOEXCEPT override {
        std::swap(instances[underlying_type::index(lhs)], instances[underlying_type::index(rhs)]);
        underlying_type::swap(lhs, rhs);
    }
 
    template<typename Compare, typename Sort = std_sort, typename... Args>
    void sort(iterator_type first, iterator_type last, Compare compare, Sort algo = Sort{}, Args &&... args) {
        ENTT_ASSERT(!(last < first));
        ENTT_ASSERT(!(last > end()));
 
        const auto from = underlying_type::begin() + std::distance(begin(), first);
        const auto to = from + std::distance(first, last);
 
        const auto apply = [this](const auto lhs, const auto rhs) {
            std::swap(instances[underlying_type::index(lhs)], instances[underlying_type::index(rhs)]);
        };
 
        if constexpr(std::is_invocable_v<Compare, const object_type &, const object_type &>) {
            underlying_type::arrange(from, to, std::move(apply), [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
                return compare(std::as_const(instances[underlying_type::index(lhs)]), std::as_const(instances[underlying_type::index(rhs)]));
            }, std::move(algo), std::forward<Args>(args)...);
        } else {
            underlying_type::arrange(from, to, std::move(apply), std::move(compare), std::move(algo), std::forward<Args>(args)...);
        }
    }
 
    void reset() {
        underlying_type::reset();
        instances.clear();
    }
 
private:
    std::vector<object_type> instances;
};
 
 
template<typename Entity, typename Type>
class basic_storage<Entity, Type, std::enable_if_t<ENTT_ENABLE_ETO(Type)>>: public sparse_set<Entity> {
    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
    using underlying_type = sparse_set<Entity>;
 
    class iterator {
        friend class basic_storage<Entity, Type>;
 
        using index_type = typename traits_type::difference_type;
 
        iterator(const index_type idx) ENTT_NOEXCEPT
            : index{idx}
        {}
 
    public:
        using difference_type = index_type;
        using value_type = Type;
        using pointer = const value_type *;
        using reference = value_type;
        using iterator_category = std::input_iterator_tag;
 
        iterator() ENTT_NOEXCEPT = default;
 
        iterator & operator++() ENTT_NOEXCEPT {
            return --index, *this;
        }
 
        iterator operator++(int) ENTT_NOEXCEPT {
            iterator orig = *this;
            return ++(*this), orig;
        }
 
        iterator & operator--() ENTT_NOEXCEPT {
            return ++index, *this;
        }
 
        iterator operator--(int) ENTT_NOEXCEPT {
            iterator orig = *this;
            return --(*this), orig;
        }
 
        iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
            index -= value;
            return *this;
        }
 
        iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
            return iterator{index-value};
        }
 
        iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
            return (*this += -value);
        }
 
        iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
            return (*this + -value);
        }
 
        difference_type operator-(const iterator &other) const ENTT_NOEXCEPT {
            return other.index - index;
        }
 
        reference operator[](const difference_type) const ENTT_NOEXCEPT {
            return {};
        }
 
        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
            return other.index == index;
        }
 
        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this == other);
        }
 
        bool operator<(const iterator &other) const ENTT_NOEXCEPT {
            return index > other.index;
        }
 
        bool operator>(const iterator &other) const ENTT_NOEXCEPT {
            return index < other.index;
        }
 
        bool operator<=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this > other);
        }
 
        bool operator>=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this < other);
        }
 
        pointer operator->() const ENTT_NOEXCEPT {
            return nullptr;
        }
 
        reference operator*() const ENTT_NOEXCEPT {
            return {};
        }
 
    private:
        index_type index;
    };
 
public:
    using object_type = Type;
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator_type = iterator;
 
    iterator_type cbegin() const ENTT_NOEXCEPT {
        const typename traits_type::difference_type pos = underlying_type::size();
        return iterator_type{pos};
    }
 
    iterator_type begin() const ENTT_NOEXCEPT {
        return cbegin();
    }
 
    iterator_type cend() const ENTT_NOEXCEPT {
        return iterator_type{};
    }
 
    iterator_type end() const ENTT_NOEXCEPT {
        return cend();
    }
 
    object_type get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
        ENTT_ASSERT(underlying_type::has(entt));
        return {};
    }
 
    template<typename It>
    iterator_type batch(It first, It last, const object_type & = {}) {
        underlying_type::batch(first, last);
        return begin();
    }
 
    template<typename Compare, typename Sort = std_sort, typename... Args>
    void sort(iterator_type first, iterator_type last, Compare compare, Sort algo = Sort{}, Args &&... args) {
        ENTT_ASSERT(!(last < first));
        ENTT_ASSERT(!(last > end()));
 
        const auto from = underlying_type::begin() + std::distance(begin(), first);
        const auto to = from + std::distance(first, last);
 
        underlying_type::sort(from, to, std::move(compare), std::move(algo), std::forward<Args>(args)...);
    }
};
 
template<typename Entity, typename Type>
struct storage: basic_storage<Entity, Type> {};
 
 
}
 
 
#endif // ENTT_ENTITY_STORAGE_HPP
 
// #include "utility.hpp"
#ifndef ENTT_ENTITY_UTILITY_HPP
#define ENTT_ENTITY_UTILITY_HPP
 
 
// #include "../core/type_traits.hpp"
 
 
 
namespace entt {
 
 
template<typename... Type>
struct exclude_t: type_list<Type...> {};
 
 
template<typename... Type>
constexpr exclude_t<Type...> exclude{};
 
 
template<typename... Type>
struct get_t: type_list<Type...>{};
 
 
template<typename... Type>
constexpr get_t<Type...> get{};
 
 
}
 
 
#endif // ENTT_ENTITY_UTILITY_HPP
 
// #include "entity.hpp"
 
// #include "group.hpp"
#ifndef ENTT_ENTITY_GROUP_HPP
#define ENTT_ENTITY_GROUP_HPP
 
 
#include <tuple>
#include <utility>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/type_traits.hpp"
 
// #include "sparse_set.hpp"
 
// #include "storage.hpp"
 
// #include "utility.hpp"
 
// #include "fwd.hpp"
 
 
 
namespace entt {
 
 
template<typename...>
class basic_group;
 
 
template<typename Entity, typename... Exclude, typename... Get>
class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>> {
    friend class basic_registry<Entity>;
 
    template<typename Component>
    using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
 
    // we could use pool_type<Type> *..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug)
    basic_group(sparse_set<Entity> *ref, storage<Entity, std::remove_const_t<Get>> *... gpool) ENTT_NOEXCEPT
        : handler{ref},
          pools{gpool...}
    {}
 
    template<typename Func, typename... Weak>
    void traverse(Func func, type_list<Weak...>) const {
        for(const auto entt: *handler) {
            if constexpr(std::is_invocable_v<Func, decltype(get<Weak>({}))...>) {
                func(std::get<pool_type<Weak> *>(pools)->get(entt)...);
            } else {
                func(entt, std::get<pool_type<Weak> *>(pools)->get(entt)...);
            }
        }
    }
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator_type = typename sparse_set<Entity>::iterator_type;
 
    template<typename Component>
    size_type size() const ENTT_NOEXCEPT {
        return std::get<pool_type<Component> *>(pools)->size();
    }
 
    size_type size() const ENTT_NOEXCEPT {
        return handler->size();
    }
 
    size_type capacity() const ENTT_NOEXCEPT {
        return handler->capacity();
    }
 
    void shrink_to_fit() {
        handler->shrink_to_fit();
    }
 
    template<typename... Component>
    bool empty() const ENTT_NOEXCEPT {
        if constexpr(sizeof...(Component) == 0) {
            return handler->empty();
        } else {
            return (std::get<pool_type<Component> *>(pools)->empty() && ...);
        }
    }
 
    template<typename Component>
    Component * raw() const ENTT_NOEXCEPT {
        return std::get<pool_type<Component> *>(pools)->raw();
    }
 
    template<typename Component>
    const entity_type * data() const ENTT_NOEXCEPT {
        return std::get<pool_type<Component> *>(pools)->data();
    }
 
    const entity_type * data() const ENTT_NOEXCEPT {
        return handler->data();
    }
 
    iterator_type begin() const ENTT_NOEXCEPT {
        return handler->begin();
    }
 
    iterator_type end() const ENTT_NOEXCEPT {
        return handler->end();
    }
 
    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
        const auto it = handler->find(entt);
        return it != end() && *it == entt ? it : end();
    }
 
    entity_type operator[](const size_type pos) const ENTT_NOEXCEPT {
        return begin()[pos];
    }
 
    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
        return find(entt) != end();
    }
 
    template<typename... Component>
    decltype(auto) get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
        ENTT_ASSERT(contains(entt));
 
        if constexpr(sizeof...(Component) == 1) {
            return (std::get<pool_type<Component> *>(pools)->get(entt), ...);
        } else {
            return std::tuple<decltype(get<Component>({}))...>{get<Component>(entt)...};
        }
    }
 
    template<typename Func>
    void each(Func func) const {
        traverse(std::move(func), type_list<Get...>{});
    }
 
    template<typename Func>
    void less(Func func) const {
        using get_type_list = type_list_cat_t<std::conditional_t<ENTT_ENABLE_ETO(Get), type_list<>, type_list<Get>>...>;
        traverse(std::move(func), get_type_list{});
    }
 
    template<typename... Component, typename Compare, typename Sort = std_sort, typename... Args>
    void sort(Compare compare, Sort algo = Sort{}, Args &&... args) {
        if constexpr(sizeof...(Component) == 0) {
            static_assert(std::is_invocable_v<Compare, const entity_type, const entity_type>);
            handler->sort(handler->begin(), handler->end(), std::move(compare), std::move(algo), std::forward<Args>(args)...);
        }  else if constexpr(sizeof...(Component) == 1) {
            handler->sort(handler->begin(), handler->end(), [this, compare = std::move(compare)](const entity_type lhs, const entity_type rhs) {
                return compare((std::get<pool_type<Component> *>(pools)->get(lhs), ...), (std::get<pool_type<Component> *>(pools)->get(rhs), ...));
            }, std::move(algo), std::forward<Args>(args)...);
        } else {
            handler->sort(handler->begin(), handler->end(), [this, compare = std::move(compare)](const entity_type lhs, const entity_type rhs) {
                return compare(std::tuple<decltype(get<Component>({}))...>{std::get<pool_type<Component> *>(pools)->get(lhs)...}, std::tuple<decltype(get<Component>({}))...>{std::get<pool_type<Component> *>(pools)->get(rhs)...});
            }, std::move(algo), std::forward<Args>(args)...);
        }
    }
 
    template<typename Component>
    void sort() const {
        handler->respect(*std::get<pool_type<Component> *>(pools));
    }
 
private:
    sparse_set<entity_type> *handler;
    const std::tuple<pool_type<Get> *...> pools;
};
 
 
template<typename Entity, typename... Exclude, typename... Get, typename... Owned>
class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned...> {
    friend class basic_registry<Entity>;
 
    template<typename Component>
    using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
 
    template<typename Component>
    using component_iterator_type = decltype(std::declval<pool_type<Component>>().begin());
 
    // we could use pool_type<Type> *..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug)
    basic_group(const std::size_t *ref, const std::size_t *extent, storage<Entity, std::remove_const_t<Owned>> *... opool, storage<Entity, std::remove_const_t<Get>> *... gpool) ENTT_NOEXCEPT
        : pools{opool..., gpool...},
          length{extent},
          super{ref}
    {}
 
    template<typename Func, typename... Strong, typename... Weak>
    void traverse(Func func, type_list<Strong...>, type_list<Weak...>) const {
        [[maybe_unused]] auto it = std::make_tuple((std::get<pool_type<Strong> *>(pools)->end() - *length)...);
        [[maybe_unused]] auto data = std::get<0>(pools)->sparse_set<entity_type>::end() - *length;
 
        for(auto next = *length; next; --next) {
            if constexpr(std::is_invocable_v<Func, decltype(get<Strong>({}))..., decltype(get<Weak>({}))...>) {
                if constexpr(sizeof...(Weak) == 0) {
                    func(*(std::get<component_iterator_type<Strong>>(it)++)...);
                } else {
                    const auto entt = *(data++);
                    func(*(std::get<component_iterator_type<Strong>>(it)++)..., std::get<pool_type<Weak> *>(pools)->get(entt)...);
                }
            } else {
                const auto entt = *(data++);
                func(entt, *(std::get<component_iterator_type<Strong>>(it)++)..., std::get<pool_type<Weak> *>(pools)->get(entt)...);
            }
        }
    }
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator_type = typename sparse_set<Entity>::iterator_type;
 
    template<typename Component>
    size_type size() const ENTT_NOEXCEPT {
        return std::get<pool_type<Component> *>(pools)->size();
    }
 
    size_type size() const ENTT_NOEXCEPT {
        return *length;
    }
 
    template<typename... Component>
    bool empty() const ENTT_NOEXCEPT {
        if constexpr(sizeof...(Component) == 0) {
            return !*length;
        } else {
            return (std::get<pool_type<Component> *>(pools)->empty() && ...);
        }
    }
 
    template<typename Component>
    Component * raw() const ENTT_NOEXCEPT {
        return std::get<pool_type<Component> *>(pools)->raw();
    }
 
    template<typename Component>
    const entity_type * data() const ENTT_NOEXCEPT {
        return std::get<pool_type<Component> *>(pools)->data();
    }
 
    const entity_type * data() const ENTT_NOEXCEPT {
        return std::get<0>(pools)->data();
    }
 
    iterator_type begin() const ENTT_NOEXCEPT {
        return std::get<0>(pools)->sparse_set<entity_type>::end() - *length;
    }
 
    iterator_type end() const ENTT_NOEXCEPT {
        return std::get<0>(pools)->sparse_set<entity_type>::end();
    }
 
    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
        const auto it = std::get<0>(pools)->find(entt);
        return it != end() && it >= begin() && *it == entt ? it : end();
    }
 
    entity_type operator[](const size_type pos) const ENTT_NOEXCEPT {
        return begin()[pos];
    }
 
    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
        return find(entt) != end();
    }
 
    template<typename... Component>
    decltype(auto) get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
        ENTT_ASSERT(contains(entt));
 
        if constexpr(sizeof...(Component) == 1) {
            return (std::get<pool_type<Component> *>(pools)->get(entt), ...);
        } else {
            return std::tuple<decltype(get<Component>({}))...>{get<Component>(entt)...};
        }
    }
 
    template<typename Func>
    void each(Func func) const {
        traverse(std::move(func), type_list<Owned...>{}, type_list<Get...>{});
    }
 
    template<typename Func>
    void less(Func func) const {
        using owned_type_list = type_list_cat_t<std::conditional_t<ENTT_ENABLE_ETO(Owned), type_list<>, type_list<Owned>>...>;
        using get_type_list = type_list_cat_t<std::conditional_t<ENTT_ENABLE_ETO(Get), type_list<>, type_list<Get>>...>;
        traverse(std::move(func), owned_type_list{}, get_type_list{});
    }
 
    bool sortable() const ENTT_NOEXCEPT {
        constexpr auto size = sizeof...(Owned) + sizeof...(Get) + sizeof...(Exclude);
        return *super == size;
    }
 
    template<typename... Component, typename Compare, typename Sort = std_sort, typename... Args>
    void sort(Compare compare, Sort algo = Sort{}, Args &&... args) {
        ENTT_ASSERT(sortable());
        auto *cpool = std::get<0>(pools);
 
        if constexpr(sizeof...(Component) == 0) {
            static_assert(std::is_invocable_v<Compare, const entity_type, const entity_type>);
            cpool->sort(cpool->end()-*length, cpool->end(), std::move(compare), std::move(algo), std::forward<Args>(args)...);
        } else if constexpr(sizeof...(Component) == 1) {
            cpool->sort(cpool->end()-*length, cpool->end(), [this, compare = std::move(compare)](const entity_type lhs, const entity_type rhs) {
                return compare((std::get<pool_type<Component> *>(pools)->get(lhs), ...), (std::get<pool_type<Component> *>(pools)->get(rhs), ...));
            }, std::move(algo), std::forward<Args>(args)...);
        } else {
            cpool->sort(cpool->end()-*length, cpool->end(), [this, compare = std::move(compare)](const entity_type lhs, const entity_type rhs) {
                return compare(std::tuple<decltype(get<Component>({}))...>{std::get<pool_type<Component> *>(pools)->get(lhs)...}, std::tuple<decltype(get<Component>({}))...>{std::get<pool_type<Component> *>(pools)->get(rhs)...});
            }, std::move(algo), std::forward<Args>(args)...);
        }
 
        [this](auto *head, auto *... other) {
            for(auto next = *length; next; --next) {
                const auto pos = next - 1;
                [[maybe_unused]] const auto entt = head->data()[pos];
                (other->swap(other->data()[pos], entt), ...);
            }
        }(std::get<pool_type<Owned> *>(pools)...);
    }
 
private:
    const std::tuple<pool_type<Owned> *..., pool_type<Get> *...> pools;
    const size_type *length;
    const size_type *super;
};
 
 
}
 
 
#endif // ENTT_ENTITY_GROUP_HPP
 
// #include "view.hpp"
#ifndef ENTT_ENTITY_VIEW_HPP
#define ENTT_ENTITY_VIEW_HPP
 
 
#include <iterator>
#include <array>
#include <tuple>
#include <utility>
#include <algorithm>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/type_traits.hpp"
 
// #include "sparse_set.hpp"
 
// #include "storage.hpp"
 
// #include "utility.hpp"
 
// #include "entity.hpp"
 
// #include "fwd.hpp"
 
 
 
namespace entt {
 
 
template<typename...>
class basic_view;
 
 
template<typename Entity, typename... Exclude, typename... Component>
class basic_view<Entity, exclude_t<Exclude...>, Component...> {
    friend class basic_registry<Entity>;
 
    template<typename Comp>
    using pool_type = std::conditional_t<std::is_const_v<Comp>, const storage<Entity, std::remove_const_t<Comp>>, storage<Entity, Comp>>;
 
    template<typename Comp>
    using component_iterator_type = decltype(std::declval<pool_type<Comp>>().begin());
 
    using underlying_iterator_type = typename sparse_set<Entity>::iterator_type;
    using unchecked_type = std::array<const sparse_set<Entity> *, (sizeof...(Component) - 1)>;
    using filter_type = std::array<const sparse_set<Entity> *, sizeof...(Exclude)>;
 
    class iterator {
        friend class basic_view<Entity, exclude_t<Exclude...>, Component...>;
 
        iterator(underlying_iterator_type first, underlying_iterator_type last, unchecked_type other, filter_type ignore) ENTT_NOEXCEPT
            : begin{first},
              end{last},
              unchecked{other},
              filter{ignore}
        {
            if(begin != end && !valid()) {
                ++(*this);
            }
        }
 
        bool valid() const ENTT_NOEXCEPT {
            return std::all_of(unchecked.cbegin(), unchecked.cend(), [this](const sparse_set<Entity> *view) { return view->has(*begin); })
                    && std::none_of(filter.cbegin(), filter.cend(), [this](const sparse_set<Entity> *view) { return view->has(*begin); });
        }
 
    public:
        using difference_type = typename underlying_iterator_type::difference_type;
        using value_type = typename underlying_iterator_type::value_type;
        using pointer = typename underlying_iterator_type::pointer;
        using reference = typename underlying_iterator_type::reference;
        using iterator_category = std::forward_iterator_tag;
 
        iterator() ENTT_NOEXCEPT = default;
 
        iterator & operator++() ENTT_NOEXCEPT {
            return (++begin != end && !valid()) ? ++(*this) : *this;
        }
 
        iterator operator++(int) ENTT_NOEXCEPT {
            iterator orig = *this;
            return ++(*this), orig;
        }
 
        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
            return other.begin == begin;
        }
 
        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
            return !(*this == other);
        }
 
        pointer operator->() const ENTT_NOEXCEPT {
            return begin.operator->();
        }
 
        reference operator*() const ENTT_NOEXCEPT {
            return *operator->();
        }
 
    private:
        underlying_iterator_type begin;
        underlying_iterator_type end;
        unchecked_type unchecked;
        filter_type filter;
    };
 
    // we could use pool_type<Component> *..., but vs complains about it and refuses to compile for unknown reasons (likely a bug)
    basic_view(storage<Entity, std::remove_const_t<Component>> *... component, storage<Entity, std::remove_const_t<Exclude>> *... epool) ENTT_NOEXCEPT
        : pools{component...},
          filter{epool...}
    {}
 
    const sparse_set<Entity> * candidate() const ENTT_NOEXCEPT {
        return std::min({ static_cast<const sparse_set<Entity> *>(std::get<pool_type<Component> *>(pools))... }, [](const auto *lhs, const auto *rhs) {
            return lhs->size() < rhs->size();
        });
    }
 
    unchecked_type unchecked(const sparse_set<Entity> *view) const ENTT_NOEXCEPT {
        std::size_t pos{};
        unchecked_type other{};
        ((std::get<pool_type<Component> *>(pools) == view ? nullptr : (other[pos++] = std::get<pool_type<Component> *>(pools))), ...);
        return other;
    }
 
    template<typename Comp, typename Other>
    decltype(auto) get([[maybe_unused]] component_iterator_type<Comp> it, [[maybe_unused]] pool_type<Other> *cpool, [[maybe_unused]] const Entity entt) const ENTT_NOEXCEPT {
        if constexpr(std::is_same_v<Comp, Other>) {
            return *it;
        } else {
            return cpool->get(entt);
        }
    }
 
    template<typename Comp, typename Func, typename... Other, typename... Type>
    void traverse(Func func, type_list<Other...>, type_list<Type...>) const {
        const auto end = std::get<pool_type<Comp> *>(pools)->sparse_set<Entity>::end();
        auto begin = std::get<pool_type<Comp> *>(pools)->sparse_set<Entity>::begin();
 
        if constexpr(std::disjunction_v<std::is_same<Comp, Type>...>) {
            std::for_each(begin, end, [this, raw = std::get<pool_type<Comp> *>(pools)->begin(), &func](const auto entity) mutable {
                auto curr = raw++;
 
                if((std::get<pool_type<Other> *>(pools)->has(entity) && ...) && (!std::get<pool_type<Exclude> *>(filter)->has(entity) && ...)) {
                    if constexpr(std::is_invocable_v<Func, decltype(get<Type>({}))...>) {
                        func(get<Comp, Type>(curr, std::get<pool_type<Type> *>(pools), entity)...);
                    } else {
                        func(entity, get<Comp, Type>(curr, std::get<pool_type<Type> *>(pools), entity)...);
                    }
                }
            });
        } else {
            std::for_each(begin, end, [this, &func](const auto entity) {
                if((std::get<pool_type<Other> *>(pools)->has(entity) && ...) && (!std::get<pool_type<Exclude> *>(filter)->has(entity) && ...)) {
                    if constexpr(std::is_invocable_v<Func, decltype(get<Type>({}))...>) {
                        func(std::get<pool_type<Type> *>(pools)->get(entity)...);
                    } else {
                        func(entity, std::get<pool_type<Type> *>(pools)->get(entity)...);
                    }
                }
            });
        }
    }
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator_type = iterator;
 
    template<typename Comp>
    size_type size() const ENTT_NOEXCEPT {
        return std::get<pool_type<Comp> *>(pools)->size();
    }
 
    size_type size() const ENTT_NOEXCEPT {
        return std::min({ std::get<pool_type<Component> *>(pools)->size()... });
    }
 
    template<typename... Comp>
    bool empty() const ENTT_NOEXCEPT {
        if constexpr(sizeof...(Comp) == 0) {
            return (std::get<pool_type<Component> *>(pools)->empty() || ...);
        } else {
            return (std::get<pool_type<Comp> *>(pools)->empty() && ...);
        }
    }
 
    template<typename Comp>
    Comp * raw() const ENTT_NOEXCEPT {
        return std::get<pool_type<Comp> *>(pools)->raw();
    }
 
    template<typename Comp>
    const entity_type * data() const ENTT_NOEXCEPT {
        return std::get<pool_type<Comp> *>(pools)->data();
    }
 
    iterator_type begin() const ENTT_NOEXCEPT {
        const auto *view = candidate();
        const filter_type ignore{std::get<pool_type<Exclude> *>(filter)...};
        return iterator_type{view->begin(), view->end(), unchecked(view), ignore};
    }
 
    iterator_type end() const ENTT_NOEXCEPT {
        const auto *view = candidate();
        const filter_type ignore{std::get<pool_type<Exclude> *>(filter)...};
        return iterator_type{view->end(), view->end(), unchecked(view), ignore};
    }
 
    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
        const auto *view = candidate();
        const filter_type ignore{std::get<pool_type<Exclude> *>(filter)...};
        iterator_type it{view->find(entt), view->end(), unchecked(view), ignore};
        return (it != end() && *it == entt) ? it : end();
    }
 
    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
        return find(entt) != end();
    }
 
    template<typename... Comp>
    decltype(auto) get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
        ENTT_ASSERT(contains(entt));
 
        if constexpr(sizeof...(Comp) == 0) {
            static_assert(sizeof...(Component) == 1);
            return (std::get<pool_type<Component> *>(pools)->get(entt), ...);
        } else if constexpr(sizeof...(Comp) == 1) {
            return (std::get<pool_type<Comp> *>(pools)->get(entt), ...);
        } else {
            return std::tuple<decltype(get<Comp>({}))...>{get<Comp>(entt)...};
        }
    }
 
    template<typename Func>
    void each(Func func) const {
        const auto *view = candidate();
        ((std::get<pool_type<Component> *>(pools) == view ? each<Component>(std::move(func)) : void()), ...);
    }
 
    template<typename Comp, typename Func>
    void each(Func func) const {
        using other_type = type_list_cat_t<std::conditional_t<std::is_same_v<Comp, Component>, type_list<>, type_list<Component>>...>;
        traverse<Comp>(std::move(func), other_type{}, type_list<Component...>{});
    }
 
    template<typename Func>
    void less(Func func) const {
        const auto *view = candidate();
        ((std::get<pool_type<Component> *>(pools) == view ? less<Component>(std::move(func)) : void()), ...);
    }
 
    template<typename Comp, typename Func>
    void less(Func func) const {
        using other_type = type_list_cat_t<std::conditional_t<std::is_same_v<Comp, Component>, type_list<>, type_list<Component>>...>;
        using non_empty_type = type_list_cat_t<std::conditional_t<ENTT_ENABLE_ETO(Component), type_list<>, type_list<Component>>...>;
        traverse<Comp>(std::move(func), other_type{}, non_empty_type{});
    }
 
private:
    const std::tuple<pool_type<Component> *...> pools;
    const std::tuple<pool_type<Exclude> *...> filter;
};
 
 
template<typename Entity, typename Component>
class basic_view<Entity, exclude_t<>, Component> {
    friend class basic_registry<Entity>;
 
    using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
 
    basic_view(pool_type *ref) ENTT_NOEXCEPT
        : pool{ref}
    {}
 
public:
    using raw_type = Component;
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator_type = typename sparse_set<Entity>::iterator_type;
 
    size_type size() const ENTT_NOEXCEPT {
        return pool->size();
    }
 
    bool empty() const ENTT_NOEXCEPT {
        return pool->empty();
    }
 
    raw_type * raw() const ENTT_NOEXCEPT {
        return pool->raw();
    }
 
    const entity_type * data() const ENTT_NOEXCEPT {
        return pool->data();
    }
 
    iterator_type begin() const ENTT_NOEXCEPT {
        return pool->sparse_set<Entity>::begin();
    }
 
    iterator_type end() const ENTT_NOEXCEPT {
        return pool->sparse_set<Entity>::end();
    }
 
    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
        const auto it = pool->find(entt);
        return it != end() && *it == entt ? it : end();
    }
 
    entity_type operator[](const size_type pos) const ENTT_NOEXCEPT {
        return begin()[pos];
    }
 
    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
        return find(entt) != end();
    }
 
    template<typename Comp = Component>
    decltype(auto) get(const entity_type entt) const ENTT_NOEXCEPT {
        static_assert(std::is_same_v<Comp, Component>);
        ENTT_ASSERT(contains(entt));
        return pool->get(entt);
    }
 
    template<typename Func>
    void each(Func func) const {
        if constexpr(std::is_invocable_v<Func, decltype(get({}))>) {
            std::for_each(pool->begin(), pool->end(), std::move(func));
        } else {
            std::for_each(pool->sparse_set<Entity>::begin(), pool->sparse_set<Entity>::end(), [&func, raw = pool->begin()](const auto entt) mutable {
                func(entt, *(raw++));
            });
        }
    }
 
    template<typename Func>
    void less(Func func) const {
        if constexpr(ENTT_ENABLE_ETO(Component)) {
            if constexpr(std::is_invocable_v<Func>) {
                for(auto pos = pool->size(); pos; --pos) {
                    func();
                }
            } else {
                std::for_each(pool->sparse_set<Entity>::begin(), pool->sparse_set<Entity>::end(), std::move(func));
            }
        } else {
            each(std::move(func));
        }
    }
 
private:
    pool_type *pool;
};
 
 
}
 
 
#endif // ENTT_ENTITY_VIEW_HPP
 
// #include "fwd.hpp"
 
 
 
namespace entt {
 
 
template<typename Entity>
class basic_registry {
    using context_family = family<struct internal_registry_context_family>;
    using component_family = family<struct internal_registry_component_family>;
    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
    template<typename Component>
    struct pool_handler: storage<Entity, Component> {
        std::size_t super{};
 
        template<typename... Args>
        pool_handler(Args &&... args)
            : storage<Entity, Component>{std::forward<Args>(args)...},
              super{}
        {}
 
        auto on_construct() ENTT_NOEXCEPT {
            return sink{construction};
        }
 
        auto on_replace() ENTT_NOEXCEPT {
            return sink{update};
        }
 
        auto on_destroy() ENTT_NOEXCEPT {
            return sink{destruction};
        }
 
        template<typename... Args>
        decltype(auto) assign(basic_registry &owner, const Entity entt, Args &&... args) {
            if constexpr(ENTT_ENABLE_ETO(Component)) {
                storage<Entity, Component>::construct(entt);
                construction.publish(entt, owner, Component{});
                return Component{std::forward<Args>(args)...};
            } else {
                auto &component = storage<Entity, Component>::construct(entt, std::forward<Args>(args)...);
                construction.publish(entt, owner, component);
                return component;
            }
        }
 
        template<typename It, typename... Args>
        auto batch(basic_registry &owner, It first, It last, Args &&... args) {
            auto it = storage<Entity, Component>::batch(first, last, std::forward<Args>(args)...);
 
            if(!construction.empty()) {
                std::for_each(first, last, [this, &owner, it](const auto entt) mutable {
                    construction.publish(entt, owner, *(it++));
                });
            }
 
            return it;
        }
 
        void remove(basic_registry &owner, const Entity entt) {
            destruction.publish(entt, owner);
            storage<Entity, Component>::destroy(entt);
        }
 
        template<typename... Args>
        decltype(auto) replace(basic_registry &owner, const Entity entt, Args &&... args) {
            if constexpr(ENTT_ENABLE_ETO(Component)) {
                ENTT_ASSERT((storage<Entity, Component>::has(entt)));
                update.publish(entt, owner, Component{});
                return Component{std::forward<Args>(args)...};
            } else {
                Component component{std::forward<Args>(args)...};
                update.publish(entt, owner, component);
                return (storage<Entity, Component>::get(entt) = std::move(component));
            }
        }
 
    private:
        using reference_type = std::conditional_t<ENTT_ENABLE_ETO(Component), const Component &, Component &>;
        sigh<void(const Entity, basic_registry &, reference_type)> construction{};
        sigh<void(const Entity, basic_registry &, reference_type)> update{};
        sigh<void(const Entity, basic_registry &)> destruction{};
    };
 
    template<typename Component>
    using pool_type = pool_handler<std::decay_t<Component>>;
 
    template<typename...>
    struct group_handler;
 
    template<typename... Exclude, typename... Get>
    struct group_handler<exclude_t<Exclude...>, get_t<Get...>> {
        const std::tuple<pool_type<Get> *..., pool_type<Exclude> *...> cpools{};
        sparse_set<Entity> set{};
 
        template<typename Component>
        void maybe_valid_if(const Entity entt) {
            if constexpr(std::disjunction_v<std::is_same<Get, Component>...>) {
                if(((std::is_same_v<Component, Get> || std::get<pool_type<Get> *>(cpools)->has(entt)) && ...)
                        && (!std::get<pool_type<Exclude> *>(cpools)->has(entt) && ...)
                        && !set.has(entt))
                {
                    set.construct(entt);
                }
            } else if constexpr(std::disjunction_v<std::is_same<Exclude, Component>...>) {
                if((std::get<pool_type<Get> *>(cpools)->has(entt) && ...)
                        && ((std::is_same_v<Exclude, Component> || !std::get<pool_type<Exclude> *>(cpools)->has(entt)) && ...)
                        && !set.has(entt))
                {
                    set.construct(entt);
                }
            }
        }
 
        void discard_if(const Entity entt) {
            if(set.has(entt)) {
                set.destroy(entt);
            }
        }
    };
 
    template<typename... Exclude, typename... Get, typename... Owned>
    struct group_handler<exclude_t<Exclude...>, get_t<Get...>, Owned...> {
        const std::tuple<pool_type<Owned> *..., pool_type<Get> *..., pool_type<Exclude> *...> cpools{};
        std::size_t owned{};
 
        template<typename Component>
        void maybe_valid_if(const Entity entt) {
            if constexpr(std::disjunction_v<std::is_same<Owned, Component>..., std::is_same<Get, Component>...>) {
                if(((std::is_same_v<Component, Owned> || std::get<pool_type<Owned> *>(cpools)->has(entt)) && ...)
                        && ((std::is_same_v<Component, Get> || std::get<pool_type<Get> *>(cpools)->has(entt)) && ...)
                        && (!std::get<pool_type<Exclude> *>(cpools)->has(entt) && ...)
                        && !(std::get<0>(cpools)->index(entt) < owned))
                {
                    const auto pos = owned++;
                    (std::get<pool_type<Owned> *>(cpools)->swap(std::get<pool_type<Owned> *>(cpools)->data()[pos], entt), ...);
                }
            } else if constexpr(std::disjunction_v<std::is_same<Exclude, Component>...>) {
                if((std::get<pool_type<Owned> *>(cpools)->has(entt) && ...)
                        && (std::get<pool_type<Get> *>(cpools)->has(entt) && ...)
                        && ((std::is_same_v<Exclude, Component> || !std::get<pool_type<Exclude> *>(cpools)->has(entt)) && ...)
                        && !(std::get<0>(cpools)->index(entt) < owned))
                {
                    const auto pos = owned++;
                    (std::get<pool_type<Owned> *>(cpools)->swap(std::get<pool_type<Owned> *>(cpools)->data()[pos], entt), ...);
                }
            }
        }
 
        void discard_if(const Entity entt) {
            if(std::get<0>(cpools)->has(entt) && std::get<0>(cpools)->index(entt) < owned) {
                const auto pos = --owned;
                (std::get<pool_type<Owned> *>(cpools)->swap(std::get<pool_type<Owned> *>(cpools)->data()[pos], entt), ...);
            }
        }
    };
 
    struct pool_data {
        std::unique_ptr<sparse_set<Entity>> pool;
        void(* remove)(sparse_set<Entity> &, basic_registry &, const Entity);
        std::unique_ptr<sparse_set<Entity>>(* clone)(const sparse_set<Entity> &);
        void(* stomp)(const sparse_set<Entity> &, const Entity, basic_registry &, const Entity);
        ENTT_ID_TYPE runtime_type;
    };
 
    struct group_data {
        std::size_t extent[3];
        std::unique_ptr<void, void(*)(void *)> group;
        bool(* owned)(const component) ENTT_NOEXCEPT;
        bool(* get)(const component) ENTT_NOEXCEPT;
        bool(* exclude)(const component) ENTT_NOEXCEPT;
    };
 
    struct ctx_variable {
        std::unique_ptr<void, void(*)(void *)> value;
        ENTT_ID_TYPE runtime_type;
    };
 
    template<typename Type, typename Family>
    static ENTT_ID_TYPE runtime_type() ENTT_NOEXCEPT {
        if constexpr(is_named_type_v<Type>) {
            return named_type_traits_v<Type>;
        } else {
            return Family::template type<std::decay_t<Type>>;
        }
    }
 
    auto generate() {
        Entity entt;
 
        if(destroyed == null) {
            entt = entities.emplace_back(entity_type(entities.size()));
            // traits_type::entity_mask is reserved to allow for null identifiers
            ENTT_ASSERT(to_integer(entt) < traits_type::entity_mask);
        } else {
            const auto curr = to_integer(destroyed);
            const auto version = to_integer(entities[curr]) & (traits_type::version_mask << traits_type::entity_shift);
            destroyed = entity_type{to_integer(entities[curr]) & traits_type::entity_mask};
            entt = entity_type{curr | version};
            entities[curr] = entt;
        }
 
        return entt;
    }
 
    void release(const Entity entity) {
        // lengthens the implicit list of destroyed entities
        const auto entt = to_integer(entity) & traits_type::entity_mask;
        const auto version = ((to_integer(entity) >> traits_type::entity_shift) + 1) << traits_type::entity_shift;
        const auto node = to_integer(destroyed) | version;
        entities[entt] = Entity{node};
        destroyed = Entity{entt};
    }
 
    template<typename Component>
    const pool_type<Component> * assure() const {
        const auto ctype = to_integer(type<Component>());
        pool_data *pdata = nullptr;
 
        if constexpr(is_named_type_v<Component>) {
            const auto it = std::find_if(pools.begin()+skip_family_pools, pools.end(), [ctype](const auto &candidate) {
                return candidate.runtime_type == ctype;
            });
 
            pdata = (it == pools.cend() ? &pools.emplace_back() : &(*it));
        } else {
            if(!(ctype < skip_family_pools)) {
                pools.reserve(pools.size()+ctype-skip_family_pools+1);
 
                while(!(ctype < skip_family_pools)) {
                    pools.emplace(pools.begin()+(skip_family_pools++), pool_data{});
                }
            }
 
            pdata = &pools[ctype];
        }
 
        if(!pdata->pool) {
            pdata->runtime_type = ctype;
            pdata->pool = std::make_unique<pool_type<Component>>();
 
            pdata->remove = [](sparse_set<Entity> &cpool, basic_registry &owner, const Entity entt) {
                static_cast<pool_type<Component> &>(cpool).remove(owner, entt);
            };
 
            if constexpr(std::is_copy_constructible_v<std::decay_t<Component>>) {
                pdata->clone = [](const sparse_set<Entity> &cpool) -> std::unique_ptr<sparse_set<Entity>> {
                    return std::make_unique<pool_type<Component>>(static_cast<const pool_type<Component> &>(cpool));
                };
 
                pdata->stomp = [](const sparse_set<Entity> &cpool, const Entity from, basic_registry &other, const Entity to) {
                    other.assign_or_replace<Component>(to, static_cast<const pool_type<Component> &>(cpool).get(from));
                };
            } else {
                pdata->clone = nullptr;
                pdata->stomp = nullptr;
            }
        }
 
        return static_cast<pool_type<Component> *>(pdata->pool.get());
    }
 
    template<typename Component>
    pool_type<Component> * assure() {
        return const_cast<pool_type<Component> *>(std::as_const(*this).template assure<Component>());
    }
 
public:
    using entity_type = Entity;
    using version_type = typename traits_type::version_type;
    using size_type = std::size_t;
 
    basic_registry() ENTT_NOEXCEPT = default;
 
    basic_registry(basic_registry &&) = default;
 
    basic_registry & operator=(basic_registry &&) = default;
 
    template<typename Component>
    static component type() ENTT_NOEXCEPT {
        return component{runtime_type<Component, component_family>()};
    }
 
    template<typename... Component>
    void prepare() {
        (assure<Component>(), ...);
    }
 
    template<typename Component>
    size_type size() const ENTT_NOEXCEPT {
        return assure<Component>()->size();
    }
 
    size_type size() const ENTT_NOEXCEPT {
        return entities.size();
    }
 
    size_type alive() const ENTT_NOEXCEPT {
        auto sz = entities.size();
        auto curr = destroyed;
 
        for(; curr != null; --sz) {
            curr = entities[to_integer(curr) & traits_type::entity_mask];
        }
 
        return sz;
    }
 
    template<typename... Component>
    void reserve(const size_type cap) {
        if constexpr(sizeof...(Component) == 0) {
            entities.reserve(cap);
        } else {
            (assure<Component>()->reserve(cap), ...);
        }
    }
 
    template<typename Component>
    size_type capacity() const ENTT_NOEXCEPT {
        return assure<Component>()->capacity();
    }
 
    size_type capacity() const ENTT_NOEXCEPT {
        return entities.capacity();
    }
 
    template<typename... Component>
    void shrink_to_fit() {
        (assure<Component>()->shrink_to_fit(), ...);
    }
 
    template<typename... Component>
    bool empty() const ENTT_NOEXCEPT {
        if constexpr(sizeof...(Component) == 0) {
            return !alive();
        } else {
            return (assure<Component>()->empty() && ...);
        }
    }
 
    template<typename Component>
    const Component * raw() const ENTT_NOEXCEPT {
        return assure<Component>()->raw();
    }
 
    template<typename Component>
    Component * raw() ENTT_NOEXCEPT {
        return const_cast<Component *>(std::as_const(*this).template raw<Component>());
    }
 
    template<typename Component>
    const entity_type * data() const ENTT_NOEXCEPT {
        return assure<Component>()->data();
    }
 
    bool valid(const entity_type entity) const ENTT_NOEXCEPT {
        const auto pos = size_type(to_integer(entity) & traits_type::entity_mask);
        return (pos < entities.size() && entities[pos] == entity);
    }
 
    static entity_type entity(const entity_type entity) ENTT_NOEXCEPT {
        return entity_type{to_integer(entity) & traits_type::entity_mask};
    }
 
    static version_type version(const entity_type entity) ENTT_NOEXCEPT {
        return version_type(to_integer(entity) >> traits_type::entity_shift);
    }
 
    version_type current(const entity_type entity) const ENTT_NOEXCEPT {
        const auto pos = size_type(to_integer(entity) & traits_type::entity_mask);
        ENTT_ASSERT(pos < entities.size());
        return version_type(to_integer(entities[pos]) >> traits_type::entity_shift);
    }
 
    template<typename... Component>
    auto create() {
        if constexpr(sizeof...(Component) == 0) {
            return generate();
        } else {
            const entity_type entt = generate();
            return std::tuple<entity_type, decltype(assign<Component>({}))...>{entt, assign<Component>(entt)...};
        }
    }
 
    template<typename... Component, typename It>
    auto create(It first, It last) {
        std::generate(first, last, [this]() { return generate(); });
 
        if constexpr(sizeof...(Component) > 0) {
            // the reverse iterators guarantee the ordering between entities and components (hint: the pools return begin())
            return std::make_tuple(assure<Component>()->batch(*this, std::make_reverse_iterator(last), std::make_reverse_iterator(first))...);
        }
    }
 
    template<typename... Component, typename... Exclude>
    entity_type create(entity_type src, const basic_registry &other, exclude_t<Exclude...> = {}) {
        const auto entt = create();
        stomp<Component...>(entt, src, other, exclude<Exclude...>);
        return entt;
    }
 
    template<typename... Component, typename It, typename... Exclude>
    void create(It first, It last, entity_type src, const basic_registry &other, exclude_t<Exclude...> = {}) {
        create(first, last);
 
        if constexpr(sizeof...(Component) == 0) {
            stomp<Component...>(first, last, src, other, exclude<Exclude...>);
        } else {
            static_assert(sizeof...(Exclude) == 0);
            (assure<Component>()->batch(*this, std::make_reverse_iterator(last), std::make_reverse_iterator(first), other.get<Component>(src)), ...);
        }
    }
 
    void destroy(const entity_type entity) {
        ENTT_ASSERT(valid(entity));
 
        for(auto pos = pools.size(); pos; --pos) {
            if(auto &pdata = pools[pos-1]; pdata.pool && pdata.pool->has(entity)) {
                pdata.remove(*pdata.pool, *this, entity);
            }
        }
 
        // just a way to protect users from listeners that attach components
        ENTT_ASSERT(orphan(entity));
        release(entity);
    }
 
    template<typename It>
    void destroy(It first, It last) {
        // useless this-> used to suppress a warning with clang
        std::for_each(first, last, [this](const auto entity) { this->destroy(entity); });
    }
 
    template<typename Component, typename... Args>
    decltype(auto) assign(const entity_type entity, [[maybe_unused]] Args &&... args) {
        ENTT_ASSERT(valid(entity));
        return assure<Component>()->assign(*this, entity, std::forward<Args>(args)...);
    }
 
    template<typename Component>
    void remove(const entity_type entity) {
        ENTT_ASSERT(valid(entity));
        assure<Component>()->remove(*this, entity);
    }
 
    template<typename... Component>
    bool has(const entity_type entity) const ENTT_NOEXCEPT {
        ENTT_ASSERT(valid(entity));
        return (assure<Component>()->has(entity) && ...);
    }
 
    template<typename... Component>
    decltype(auto) get([[maybe_unused]] const entity_type entity) const {
        ENTT_ASSERT(valid(entity));
 
        if constexpr(sizeof...(Component) == 1) {
            return (assure<Component>()->get(entity), ...);
        } else {
            return std::tuple<decltype(get<Component>({}))...>{get<Component>(entity)...};
        }
    }
 
    template<typename... Component>
    decltype(auto) get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT {
        ENTT_ASSERT(valid(entity));
 
        if constexpr(sizeof...(Component) == 1) {
            return (assure<Component>()->get(entity), ...);
        } else {
            return std::tuple<decltype(get<Component>({}))...>{get<Component>(entity)...};
        }
    }
 
    template<typename Component, typename... Args>
    decltype(auto) get_or_assign(const entity_type entity, Args &&... args) ENTT_NOEXCEPT {
        ENTT_ASSERT(valid(entity));
        auto *cpool = assure<Component>();
        return cpool->has(entity) ? cpool->get(entity) : cpool->assign(*this, entity, std::forward<Args>(args)...);
    }
 
    template<typename... Component>
    auto try_get([[maybe_unused]] const entity_type entity) const ENTT_NOEXCEPT {
        ENTT_ASSERT(valid(entity));
 
        if constexpr(sizeof...(Component) == 1) {
            return (assure<Component>()->try_get(entity), ...);
        } else {
            return std::tuple<decltype(try_get<Component>({}))...>{try_get<Component>(entity)...};
        }
    }
 
    template<typename... Component>
    auto try_get([[maybe_unused]] const entity_type entity) ENTT_NOEXCEPT {
        if constexpr(sizeof...(Component) == 1) {
            return (assure<Component>()->try_get(entity), ...);
        } else {
            return std::tuple<decltype(try_get<Component>({}))...>{try_get<Component>(entity)...};
        }
    }
 
    template<typename Component, typename... Args>
    decltype(auto) replace(const entity_type entity, Args &&... args) {
        ENTT_ASSERT(valid(entity));
        return assure<Component>()->replace(*this, entity, std::forward<Args>(args)...);
    }
 
    template<typename Component, typename... Args>
    decltype(auto) assign_or_replace(const entity_type entity, Args &&... args) {
        ENTT_ASSERT(valid(entity));
        auto *cpool = assure<Component>();
        return cpool->has(entity) ? cpool->replace(*this, entity, std::forward<Args>(args)...) : cpool->assign(*this, entity, std::forward<Args>(args)...);
    }
 
    template<typename Component>
    auto on_construct() ENTT_NOEXCEPT {
        return assure<Component>()->on_construct();
    }
 
    template<typename Component>
    auto on_replace() ENTT_NOEXCEPT {
        return assure<Component>()->on_replace();
    }
 
    template<typename Component>
    auto on_destroy() ENTT_NOEXCEPT {
        return assure<Component>()->on_destroy();
    }
 
    template<typename Component, typename Compare, typename Sort = std_sort, typename... Args>
    void sort(Compare compare, Sort algo = Sort{}, Args &&... args) {
        auto *cpool = assure<Component>();
        ENTT_ASSERT(!cpool->super);
        cpool->sort(cpool->begin(), cpool->end(), std::move(compare), std::move(algo), std::forward<Args>(args)...);
    }
 
    template<typename To, typename From>
    void sort() {
        auto *cpool = assure<To>();
        ENTT_ASSERT(!cpool->super);
        cpool->respect(*assure<From>());
    }
 
    template<typename Component>
    void reset(const entity_type entity) {
        ENTT_ASSERT(valid(entity));
 
        if(auto *cpool = assure<Component>(); cpool->has(entity)) {
            cpool->remove(*this, entity);
        }
    }
 
    template<typename Component>
    void reset() {
        if(auto *cpool = assure<Component>(); cpool->on_destroy().empty()) {
            // no group set, otherwise the signal wouldn't be empty
            cpool->reset();
        } else {
            for(const auto entity: static_cast<const sparse_set<entity_type> &>(*cpool)) {
                cpool->remove(*this, entity);
            }
        }
    }
 
    void reset() {
        each([this](const auto entity) {
            // useless this-> used to suppress a warning with clang
            this->destroy(entity);
        });
    }
 
    template<typename Func>
    void each(Func func) const {
        static_assert(std::is_invocable_v<Func, entity_type>);
 
        if(destroyed == null) {
            for(auto pos = entities.size(); pos; --pos) {
                func(entities[pos-1]);
            }
        } else {
            for(auto pos = entities.size(); pos; --pos) {
                const auto curr = entity_type(pos - 1);
                const auto entity = entities[to_integer(curr)];
                const auto entt = entity_type{to_integer(entity) & traits_type::entity_mask};
 
                if(curr == entt) {
                    func(entity);
                }
            }
        }
    }
 
    bool orphan(const entity_type entity) const {
        ENTT_ASSERT(valid(entity));
        bool orphan = true;
 
        for(std::size_t pos{}, last = pools.size(); pos < last && orphan; ++pos) {
            const auto &pdata = pools[pos];
            orphan = !(pdata.pool && pdata.pool->has(entity));
        }
 
        return orphan;
    }
 
    template<typename Func>
    void orphans(Func func) const {
        static_assert(std::is_invocable_v<Func, entity_type>);
 
        each([this, &func](const auto entity) {
            if(orphan(entity)) {
                func(entity);
            }
        });
    }
 
    template<typename... Component, typename... Exclude>
    entt::basic_view<Entity, exclude_t<Exclude...>, Component...> view(exclude_t<Exclude...> = {}) {
        static_assert(sizeof...(Component) > 0);
        return { assure<Component>()..., assure<Exclude>()... };
    }
 
    template<typename... Component, typename... Exclude>
    entt::basic_view<Entity, exclude_t<Exclude...>, Component...> view(exclude_t<Exclude...> = {}) const {
        static_assert(std::conjunction_v<std::is_const<Component>...>);
        return const_cast<basic_registry *>(this)->view<Component...>(exclude<Exclude...>);
    }
 
    template<typename... Component>
    bool sortable() const ENTT_NOEXCEPT {
        return !(assure<Component>()->super || ...);
    }
 
    template<typename... Owned, typename... Get, typename... Exclude>
    entt::basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned...> group(get_t<Get...>, exclude_t<Exclude...> = {}) {
        static_assert(sizeof...(Owned) + sizeof...(Get) > 0);
        static_assert(sizeof...(Owned) + sizeof...(Get) + sizeof...(Exclude) > 1);
 
        using handler_type = group_handler<exclude_t<Exclude...>, get_t<Get...>, Owned...>;
 
        [[maybe_unused]] constexpr auto size = sizeof...(Owned) + sizeof...(Get) + sizeof...(Exclude);
        const auto cpools = std::make_tuple(assure<Owned>()..., assure<Get>()..., assure<Exclude>()...);
        const std::size_t extent[3]{sizeof...(Owned), sizeof...(Get), sizeof...(Exclude)};
        handler_type *handler = nullptr;
 
        if(auto it = std::find_if(groups.cbegin(), groups.cend(), [&extent](const auto &gdata) {
            return std::equal(std::begin(extent), std::end(extent), std::begin(gdata.extent))
                    && (gdata.owned(type<Owned>()) && ...)
                    && (gdata.get(type<Get>()) && ...)
                    && (gdata.exclude(type<Exclude>()) && ...);
        }); it != groups.cend())
        {
            handler = static_cast<handler_type *>(it->group.get());
        }
 
        if(!handler) {
            const void *maybe_valid_if = nullptr;
            const void *discard_if = nullptr;
 
            group_data gdata{
                { sizeof...(Owned), sizeof...(Get), sizeof...(Exclude) },
                decltype(group_data::group){new handler_type{cpools}, [](void *gptr) { delete static_cast<handler_type *>(gptr); }},
                [](const component ctype) ENTT_NOEXCEPT { return ((ctype == type<Owned>()) || ...); },
                [](const component ctype) ENTT_NOEXCEPT { return ((ctype == type<Get>()) || ...); },
                [](const component ctype) ENTT_NOEXCEPT { return ((ctype == type<Exclude>()) || ...); }
            };
 
            if constexpr(sizeof...(Owned) == 0) {
                handler = static_cast<handler_type *>(groups.emplace_back(std::move(gdata)).group.get());
            } else {
                ENTT_ASSERT(std::all_of(groups.cbegin(), groups.cend(), [&extent](const auto &curr) {
                    const std::size_t diff[3]{ (0u + ... + curr.owned(type<Owned>())), (0u + ... + curr.get(type<Get>())), (0u + ... + curr.exclude(type<Exclude>())) };
                    return !diff[0] || ((std::equal(std::begin(diff), std::end(diff), extent) || std::equal(std::begin(diff), std::end(diff), curr.extent)));
                }));
 
                const auto next = std::find_if_not(groups.cbegin(), groups.cend(), [&size](const auto &curr) {
                    const std::size_t diff = (0u + ... + curr.owned(type<Owned>()));
                    return !diff || (size > (curr.extent[0] + curr.extent[1] + curr.extent[2]));
                });
 
                const auto prev = std::find_if(std::make_reverse_iterator(next), groups.crend(), [](const auto &curr) {
                    return (0u + ... + curr.owned(type<Owned>()));
                });
 
                maybe_valid_if = (next == groups.cend() ? maybe_valid_if : next->group.get());
                discard_if = (prev == groups.crend() ? discard_if : prev->group.get());
                handler = static_cast<handler_type *>(groups.insert(next, std::move(gdata))->group.get());
            }
 
            ((std::get<pool_type<Owned> *>(cpools)->super = std::max(std::get<pool_type<Owned> *>(cpools)->super, size)), ...);
 
            (std::get<pool_type<Owned> *>(cpools)->on_construct().before(maybe_valid_if).template connect<&handler_type::template maybe_valid_if<Owned>>(*handler), ...);
            (std::get<pool_type<Get> *>(cpools)->on_construct().before(maybe_valid_if).template connect<&handler_type::template maybe_valid_if<Get>>(*handler), ...);
            (std::get<pool_type<Exclude> *>(cpools)->on_destroy().before(maybe_valid_if).template connect<&handler_type::template maybe_valid_if<Exclude>>(*handler), ...);
 
            (std::get<pool_type<Owned> *>(cpools)->on_destroy().before(discard_if).template connect<&handler_type::discard_if>(*handler), ...);
            (std::get<pool_type<Get> *>(cpools)->on_destroy().before(discard_if).template connect<&handler_type::discard_if>(*handler), ...);
            (std::get<pool_type<Exclude> *>(cpools)->on_construct().before(discard_if).template connect<&handler_type::discard_if>(*handler), ...);
 
            const auto *cpool = std::min({
                static_cast<sparse_set<Entity> *>(std::get<pool_type<Owned> *>(cpools))...,
                static_cast<sparse_set<Entity> *>(std::get<pool_type<Get> *>(cpools))...
            }, [](const auto *lhs, const auto *rhs) {
                return lhs->size() < rhs->size();
            });
 
            // we cannot iterate backwards because we want to leave behind valid entities in case of owned types
            std::for_each(cpool->data(), cpool->data() + cpool->size(), [cpools, handler](const auto entity) {
                if((std::get<pool_type<Owned> *>(cpools)->has(entity) && ...)
                        && (std::get<pool_type<Get> *>(cpools)->has(entity) && ...)
                        && !(std::get<pool_type<Exclude> *>(cpools)->has(entity) || ...))
                {
                    if constexpr(sizeof...(Owned) == 0) {
                        handler->set.construct(entity);
                    } else {
                        if(!(std::get<0>(cpools)->index(entity) < handler->owned)) {
                            const auto pos = handler->owned++;
                            (std::get<pool_type<Owned> *>(cpools)->swap(std::get<pool_type<Owned> *>(cpools)->data()[pos], entity), ...);
                        }
                    }
                }
            });
        }
 
        if constexpr(sizeof...(Owned) == 0) {
            return { &handler->set, std::get<pool_type<Get> *>(cpools)... };
        } else {
            return { &std::get<0>(cpools)->super, &handler->owned, std::get<pool_type<Owned> *>(cpools)... , std::get<pool_type<Get> *>(cpools)... };
        }
    }
 
    template<typename... Owned, typename... Get, typename... Exclude>
    entt::basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned...> group(get_t<Get...>, exclude_t<Exclude...> = {}) const {
        static_assert(std::conjunction_v<std::is_const<Owned>..., std::is_const<Get>...>);
        return const_cast<basic_registry *>(this)->group<Owned...>(entt::get<Get...>, exclude<Exclude...>);
    }
 
    template<typename... Owned, typename... Exclude>
    entt::basic_group<Entity, exclude_t<Exclude...>, get_t<>, Owned...> group(exclude_t<Exclude...> = {}) {
        return group<Owned...>(entt::get<>, exclude<Exclude...>);
    }
 
    template<typename... Owned, typename... Exclude>
    entt::basic_group<Entity, exclude_t<Exclude...>, get_t<>, Owned...> group(exclude_t<Exclude...> = {}) const {
        static_assert(std::conjunction_v<std::is_const<Owned>...>);
        return const_cast<basic_registry *>(this)->group<Owned...>(exclude<Exclude...>);
    }
 
    template<typename It>
    entt::basic_runtime_view<Entity> runtime_view(It first, It last) const {
        std::vector<const sparse_set<Entity> *> selected(std::distance(first, last));
 
        std::transform(first, last, selected.begin(), [this](const component ctype) {
            auto it = std::find_if(pools.begin(), pools.end(), [ctype = to_integer(ctype)](const auto &pdata) {
                return pdata.pool && pdata.runtime_type == ctype;
            });
 
            return it != pools.cend() && it->pool ? it->pool.get() : nullptr;
        });
 
        return { std::move(selected) };
    }
 
    template<typename... Component, typename... Exclude>
    basic_registry clone(exclude_t<Exclude...> = {}) const {
        static_assert(std::conjunction_v<std::is_copy_constructible<Component>...>);
        basic_registry other;
 
        other.pools.resize(pools.size());
 
        for(auto pos = pools.size(); pos; --pos) {
            const auto &pdata = pools[pos-1];
            ENTT_ASSERT(!sizeof...(Component) || !pdata.pool || pdata.clone);
 
            if(pdata.pool && pdata.clone
                    && (!sizeof...(Component) || ... || (pdata.runtime_type == to_integer(type<Component>())))
                    && ((pdata.runtime_type != to_integer(type<Exclude>())) && ...))
            {
                auto &curr = other.pools[pos-1];
                curr.remove = pdata.remove;
                curr.clone = pdata.clone;
                curr.stomp = pdata.stomp;
                curr.pool = pdata.clone ? pdata.clone(*pdata.pool) : nullptr;
                curr.runtime_type = pdata.runtime_type;
            }
        }
 
        other.skip_family_pools = skip_family_pools;
        other.destroyed = destroyed;
        other.entities = entities;
 
        other.pools.erase(std::remove_if(other.pools.begin()+skip_family_pools, other.pools.end(), [](const auto &pdata) {
            return !pdata.pool;
        }), other.pools.end());
 
        return other;
    }
 
    template<typename... Component, typename... Exclude>
    void stomp(const entity_type dst, const entity_type src, const basic_registry &other, exclude_t<Exclude...> = {}) {
        const entity_type entt[1]{dst};
        stomp<Component...>(std::begin(entt), std::end(entt), src, other, exclude<Exclude...>);
    }
 
    template<typename... Component, typename It, typename... Exclude>
    void stomp(It first, It last, const entity_type src, const basic_registry &other, exclude_t<Exclude...> = {}) {
        static_assert(sizeof...(Component) == 0 || sizeof...(Exclude) == 0);
 
        for(auto pos = other.pools.size(); pos; --pos) {
            const auto &pdata = other.pools[pos-1];
            ENTT_ASSERT(!sizeof...(Component) || !pdata.pool || pdata.stomp);
 
            if(pdata.pool && pdata.stomp
                    && (!sizeof...(Component) || ... || (pdata.runtime_type == to_integer(type<Component>())))
                    && ((pdata.runtime_type != to_integer(type<Exclude>())) && ...)
                    && pdata.pool->has(src))
            {
                std::for_each(first, last, [this, &pdata, src](const auto entity) {
                    pdata.stomp(*pdata.pool, src, *this, entity);
                });
            }
        }
    }
 
    entt::basic_snapshot<Entity> snapshot() const ENTT_NOEXCEPT {
        using follow_fn_type = entity_type(const basic_registry &, const entity_type);
 
        const auto head = to_integer(destroyed);
        const entity_type seed = (destroyed == null) ? destroyed : entity_type{head | (to_integer(entities[head]) & (traits_type::version_mask << traits_type::entity_shift))};
 
        follow_fn_type *follow = [](const basic_registry &reg, const entity_type entity) -> entity_type {
            const auto &others = reg.entities;
            const auto entt = to_integer(entity) & traits_type::entity_mask;
            const auto curr = to_integer(others[entt]) & traits_type::entity_mask;
            return entity_type{curr | (to_integer(others[curr]) & (traits_type::version_mask << traits_type::entity_shift))};
        };
 
        return { this, seed, follow };
    }
 
    basic_snapshot_loader<Entity> loader() ENTT_NOEXCEPT {
        using force_fn_type = void(basic_registry &, const entity_type, const bool);
 
        force_fn_type *force = [](basic_registry &reg, const entity_type entity, const bool discard) {
            const auto entt = to_integer(entity) & traits_type::entity_mask;
            auto &others = reg.entities;
 
            if(!(entt < others.size())) {
                auto curr = others.size();
                others.resize(entt + 1);
 
                std::generate(others.data() + curr, others.data() + entt, [curr]() mutable {
                    return entity_type(curr++);
                });
            }
 
            others[entt] = entity;
 
            if(discard) {
                reg.destroy(entity);
                const auto version = to_integer(entity) & (traits_type::version_mask << traits_type::entity_shift);
                others[entt] = entity_type{(to_integer(others[entt]) & traits_type::entity_mask) | version};
            }
        };
 
        reset();
        entities.clear();
        destroyed = null;
 
        return { this, force };
    }
 
    template<typename Type, typename... Args>
    Type & set(Args &&... args) {
        const auto ctype = runtime_type<Type, context_family>();
        auto it = std::find_if(vars.begin(), vars.end(), [ctype](const auto &candidate) {
            return candidate.runtime_type == ctype;
        });
 
        if(it == vars.cend()) {
            vars.push_back({
                decltype(ctx_variable::value){new Type{std::forward<Args>(args)...}, [](void *ptr) { delete static_cast<Type *>(ptr); }},
                ctype
            });
 
            it = std::prev(vars.end());
        } else {
            it->value.reset(new Type{std::forward<Args>(args)...});
        }
 
        return *static_cast<Type *>(it->value.get());
    }
 
    template<typename Type>
    void unset() {
        vars.erase(std::remove_if(vars.begin(), vars.end(), [](auto &var) {
            return var.runtime_type == runtime_type<Type, context_family>();
        }), vars.end());
    }
 
    template<typename Type, typename... Args>
    Type & ctx_or_set(Args &&... args) {
        auto *value = try_ctx<Type>();
        return value ? *value : set<Type>(std::forward<Args>(args)...);
    }
 
    template<typename Type>
    const Type * try_ctx() const ENTT_NOEXCEPT {
        const auto it = std::find_if(vars.begin(), vars.end(), [](const auto &var) {
            return var.runtime_type == runtime_type<Type, context_family>();
        });
 
        return (it == vars.cend()) ? nullptr : static_cast<const Type *>(it->value.get());
    }
 
    template<typename Type>
    Type * try_ctx() ENTT_NOEXCEPT {
        return const_cast<Type *>(std::as_const(*this).template try_ctx<Type>());
    }
 
    template<typename Type>
    const Type & ctx() const ENTT_NOEXCEPT {
        const auto *instance = try_ctx<Type>();
        ENTT_ASSERT(instance);
        return *instance;
    }
 
    template<typename Type>
    Type & ctx() ENTT_NOEXCEPT {
        return const_cast<Type &>(std::as_const(*this).template ctx<Type>());
    }
 
private:
    mutable std::size_t skip_family_pools{};
    mutable std::vector<pool_data> pools{};
    std::vector<group_data> groups{};
    std::vector<ctx_variable> vars{};
    std::vector<entity_type> entities{};
    entity_type destroyed{null};
};
 
 
}
 
 
#endif // ENTT_ENTITY_REGISTRY_HPP
 
// #include "entity.hpp"
 
// #include "fwd.hpp"
 
 
 
namespace entt {
 
 
template<typename Entity>
struct basic_actor {
    using registry_type = basic_registry<Entity>;
    using entity_type = Entity;
 
    basic_actor() ENTT_NOEXCEPT
        : entt{entt::null}, reg{nullptr}
    {}
 
    explicit basic_actor(registry_type &ref)
        : entt{ref.create()}, reg{&ref}
    {}
 
    explicit basic_actor(entity_type entity, registry_type &ref)
        : entt{entity}, reg{&ref}
    {
        ENTT_ASSERT(ref.valid(entity));
    }
 
    virtual ~basic_actor() {
        if(*this) {
            reg->destroy(entt);
        }
    }
 
    basic_actor(basic_actor &&other)
        : entt{other.entt}, reg{other.reg}
    {
        other.entt = null;
    }
 
    basic_actor & operator=(basic_actor &&other) {
        if(this != &other) {
            auto tmp{std::move(other)};
            std::swap(reg, tmp.reg);
            std::swap(entt, tmp.entt);
        }
 
        return *this;
    }
 
    template<typename Component, typename... Args>
    decltype(auto) assign(Args &&... args) {
        return reg->template assign_or_replace<Component>(entt, std::forward<Args>(args)...);
    }
 
    template<typename Component>
    void remove() {
        reg->template remove<Component>(entt);
    }
 
    template<typename... Component>
    bool has() const ENTT_NOEXCEPT {
        return (reg->template has<Component>(entt) && ...);
    }
 
    template<typename... Component>
    decltype(auto) get() const ENTT_NOEXCEPT {
        return std::as_const(*reg).template get<Component...>(entt);
    }
 
    template<typename... Component>
    decltype(auto) get() ENTT_NOEXCEPT {
        return reg->template get<Component...>(entt);
    }
 
    template<typename... Component>
    auto try_get() const ENTT_NOEXCEPT {
        return std::as_const(*reg).template try_get<Component...>(entt);
    }
 
    template<typename... Component>
    auto try_get() ENTT_NOEXCEPT {
        return reg->template try_get<Component...>(entt);
    }
 
    const registry_type & backend() const ENTT_NOEXCEPT {
        return *reg;
    }
 
    registry_type & backend() ENTT_NOEXCEPT {
        return const_cast<registry_type &>(std::as_const(*this).backend());
    }
 
    entity_type entity() const ENTT_NOEXCEPT {
        return entt;
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return reg && reg->valid(entt);
    }
 
private:
    entity_type entt;
    registry_type *reg;
};
 
 
}
 
 
#endif // ENTT_ENTITY_ACTOR_HPP
 
// #include "entity/entity.hpp"
 
// #include "entity/group.hpp"
 
// #include "entity/helper.hpp"
#ifndef ENTT_ENTITY_HELPER_HPP
#define ENTT_ENTITY_HELPER_HPP
 
 
#include <type_traits>
// #include "../config/config.h"
 
// #include "../signal/sigh.hpp"
 
// #include "registry.hpp"
 
 
 
namespace entt {
 
 
template<bool Const, typename Entity>
struct as_view {
    using registry_type = std::conditional_t<Const, const entt::basic_registry<Entity>, entt::basic_registry<Entity>>;
 
    as_view(registry_type &source) ENTT_NOEXCEPT: reg{source} {}
 
    template<typename Exclude, typename... Component>
    operator entt::basic_view<Entity, Exclude, Component...>() const {
        return reg.template view<Component...>(Exclude{});
    }
 
private:
    registry_type &reg;
};
 
 
template<typename Entity>
as_view(basic_registry<Entity> &) ENTT_NOEXCEPT -> as_view<false, Entity>;
 
 
template<typename Entity>
as_view(const basic_registry<Entity> &) ENTT_NOEXCEPT -> as_view<true, Entity>;
 
 
template<bool Const, typename Entity>
struct as_group {
    using registry_type = std::conditional_t<Const, const entt::basic_registry<Entity>, entt::basic_registry<Entity>>;
 
    as_group(registry_type &source) ENTT_NOEXCEPT: reg{source} {}
 
    template<typename Exclude, typename Get, typename... Owned>
    operator entt::basic_group<Entity, Exclude, Get, Owned...>() const {
        return reg.template group<Owned...>(Get{}, Exclude{});
    }
 
private:
    registry_type &reg;
};
 
 
template<typename Entity>
as_group(basic_registry<Entity> &) ENTT_NOEXCEPT -> as_group<false, Entity>;
 
 
template<typename Entity>
as_group(const basic_registry<Entity> &) ENTT_NOEXCEPT -> as_group<true, Entity>;
 
 
template<ENTT_ID_TYPE Value>
using tag = std::integral_constant<ENTT_ID_TYPE, Value>;
 
 
}
 
 
#endif // ENTT_ENTITY_HELPER_HPP
 
// #include "entity/observer.hpp"
#ifndef ENTT_ENTITY_OBSERVER_HPP
#define ENTT_ENTITY_OBSERVER_HPP
 
 
#include <limits>
#include <cstddef>
#include <cstdint>
#include <utility>
#include <algorithm>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/type_traits.hpp"
 
// #include "registry.hpp"
 
// #include "storage.hpp"
 
// #include "entity.hpp"
 
// #include "fwd.hpp"
 
 
 
namespace entt {
 
 
template<typename...>
struct matcher {};
 
 
template<typename...>
struct basic_collector;
 
 
template<>
struct basic_collector<> {
    template<typename... AllOf, typename... NoneOf>
    static constexpr auto group(exclude_t<NoneOf...> = {}) ENTT_NOEXCEPT {
        return basic_collector<matcher<type_list<>, type_list<>, type_list<NoneOf...>, AllOf...>>{};
    }
 
    template<typename AnyOf>
    static constexpr auto replace() ENTT_NOEXCEPT {
        return basic_collector<matcher<type_list<>, type_list<>, AnyOf>>{};
    }
};
 
template<typename... Reject, typename... Require, typename... Rule, typename... Other>
struct basic_collector<matcher<type_list<Reject...>, type_list<Require...>, Rule...>, Other...> {
    using current_type = matcher<type_list<Reject...>, type_list<Require...>, Rule...>;
 
    template<typename... AllOf, typename... NoneOf>
    static constexpr auto group(exclude_t<NoneOf...> = {}) ENTT_NOEXCEPT {
        return basic_collector<matcher<type_list<>, type_list<>, type_list<NoneOf...>, AllOf...>, current_type, Other...>{};
    }
 
    template<typename AnyOf>
    static constexpr auto replace() ENTT_NOEXCEPT {
        return basic_collector<matcher<type_list<>, type_list<>, AnyOf>, current_type, Other...>{};
    }
 
    template<typename... AllOf, typename... NoneOf>
    static constexpr auto where(exclude_t<NoneOf...> = {}) ENTT_NOEXCEPT {
        using extended_type = matcher<type_list<Reject..., NoneOf...>, type_list<Require..., AllOf...>, Rule...>;
        return basic_collector<extended_type, Other...>{};
    }
};
 
 
constexpr basic_collector<> collector{};
 
 
template<typename Entity>
class basic_observer {
    using payload_type = std::uint32_t;
 
    template<typename>
    struct matcher_handler;
 
    template<typename... Reject, typename... Require, typename AnyOf>
    struct matcher_handler<matcher<type_list<Reject...>, type_list<Require...>, AnyOf>> {
        template<std::size_t Index>
        static void maybe_valid_if(basic_observer &obs, const Entity entt, const basic_registry<Entity> &reg) {
            if(reg.template has<Require...>(entt) && !(reg.template has<Reject>(entt) || ...)) {
                auto *comp = obs.view.try_get(entt);
                (comp ? *comp : obs.view.construct(entt)) |= (1 << Index);
            }
        }
 
        template<std::size_t Index>
        static void discard_if(basic_observer &obs, const Entity entt) {
            if(auto *value = obs.view.try_get(entt); value && !(*value &= (~(1 << Index)))) {
                obs.view.destroy(entt);
            }
        }
 
        template<std::size_t Index>
        static void connect(basic_observer &obs, basic_registry<Entity> &reg) {
            (reg.template on_destroy<Require>().template connect<&discard_if<Index>>(obs), ...);
            (reg.template on_construct<Reject>().template connect<&discard_if<Index>>(obs), ...);
            reg.template on_replace<AnyOf>().template connect<&maybe_valid_if<Index>>(obs);
            reg.template on_destroy<AnyOf>().template connect<&discard_if<Index>>(obs);
        }
 
        static void disconnect(basic_observer &obs, basic_registry<Entity> &reg) {
            (reg.template on_destroy<Require>().disconnect(obs), ...);
            (reg.template on_construct<Reject>().disconnect(obs), ...);
            reg.template on_replace<AnyOf>().disconnect(obs);
            reg.template on_destroy<AnyOf>().disconnect(obs);
        }
    };
 
    template<typename... Reject, typename... Require, typename... NoneOf, typename... AllOf>
    struct matcher_handler<matcher<type_list<Reject...>, type_list<Require...>, type_list<NoneOf...>, AllOf...>> {
        template<std::size_t Index>
        static void maybe_valid_if(basic_observer &obs, const Entity entt, const basic_registry<Entity> &reg) {
            if(reg.template has<AllOf..., Require...>(entt) && !(reg.template has<NoneOf>(entt) || ...) && !(reg.template has<Reject>(entt) || ...)) {
                auto *comp = obs.view.try_get(entt);
                (comp ? *comp : obs.view.construct(entt)) |= (1 << Index);
            }
        }
 
        template<std::size_t Index>
        static void discard_if(basic_observer &obs, const Entity entt) {
            if(auto *value = obs.view.try_get(entt); value && !(*value &= (~(1 << Index)))) {
                obs.view.destroy(entt);
            }
        }
 
        template<std::size_t Index>
        static void connect(basic_observer &obs, basic_registry<Entity> &reg) {
            (reg.template on_destroy<Require>().template connect<&discard_if<Index>>(obs), ...);
            (reg.template on_construct<Reject>().template connect<&discard_if<Index>>(obs), ...);
            (reg.template on_construct<AllOf>().template connect<&maybe_valid_if<Index>>(obs), ...);
            (reg.template on_destroy<NoneOf>().template connect<&maybe_valid_if<Index>>(obs), ...);
            (reg.template on_destroy<AllOf>().template connect<&discard_if<Index>>(obs), ...);
            (reg.template on_construct<NoneOf>().template connect<&discard_if<Index>>(obs), ...);
        }
 
        static void disconnect(basic_observer &obs, basic_registry<Entity> &reg) {
            (reg.template on_destroy<Require>().disconnect(obs), ...);
            (reg.template on_construct<Reject>().disconnect(obs), ...);
            (reg.template on_construct<AllOf>().disconnect(obs), ...);
            (reg.template on_destroy<NoneOf>().disconnect(obs), ...);
            (reg.template on_destroy<AllOf>().disconnect(obs), ...);
            (reg.template on_construct<NoneOf>().disconnect(obs), ...);
        }
    };
 
    template<typename... Matcher>
    static void disconnect(basic_observer &obs, basic_registry<Entity> &reg) {
        (matcher_handler<Matcher>::disconnect(obs, reg), ...);
    }
 
    template<typename... Matcher, std::size_t... Index>
    void connect(basic_registry<Entity> &reg, std::index_sequence<Index...>) {
        static_assert(sizeof...(Matcher) < std::numeric_limits<payload_type>::digits);
        (matcher_handler<Matcher>::template connect<Index>(*this, reg), ...);
        release = &basic_observer::disconnect<Matcher...>;
    }
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using iterator_type = typename sparse_set<Entity>::iterator_type;
 
    basic_observer() ENTT_NOEXCEPT
        : target{}, release{}, view{}
    {}
 
    basic_observer(const basic_observer &) = delete;
    basic_observer(basic_observer &&) = delete;
 
    template<typename... Matcher>
    basic_observer(basic_registry<entity_type> &reg, basic_collector<Matcher...>) ENTT_NOEXCEPT
        : target{&reg},
          release{},
          view{}
    {
        connect<Matcher...>(reg, std::index_sequence_for<Matcher...>{});
    }
 
    ~basic_observer() = default;
 
    basic_observer & operator=(const basic_observer &) = delete;
 
    basic_observer & operator=(basic_observer &&) = delete;
 
    template<typename... Matcher>
    void connect(basic_registry<entity_type> &reg, basic_collector<Matcher...>) {
        disconnect();
        connect<Matcher...>(reg, std::index_sequence_for<Matcher...>{});
        target = &reg;
        view.reset();
    }
 
    void disconnect() {
        if(release) {
            release(*this, *target);
            release = nullptr;
        }
    }
 
    size_type size() const ENTT_NOEXCEPT {
        return view.size();
    }
 
    bool empty() const ENTT_NOEXCEPT {
        return view.empty();
    }
 
    const entity_type * data() const ENTT_NOEXCEPT {
        return view.data();
    }
 
    iterator_type begin() const ENTT_NOEXCEPT {
        return view.sparse_set<entity_type>::begin();
    }
 
    iterator_type end() const ENTT_NOEXCEPT {
        return view.sparse_set<entity_type>::end();
    }
 
    void clear() {
        view.reset();
    }
 
    template<typename Func>
    void each(Func func) const {
        static_assert(std::is_invocable_v<Func, entity_type>);
        std::for_each(begin(), end(), std::move(func));
    }
 
    template<typename Func>
    void each(Func func) {
        std::as_const(*this).each(std::move(func));
        clear();
    }
 
private:
    basic_registry<entity_type> *target;
    void(* release)(basic_observer &, basic_registry<entity_type> &);
    storage<entity_type, payload_type> view;
};
 
 
}
 
 
#endif // ENTT_ENTITY_OBSERVER_HPP
 
// #include "entity/registry.hpp"
 
// #include "entity/runtime_view.hpp"
 
// #include "entity/snapshot.hpp"
 
// #include "entity/sparse_set.hpp"
 
// #include "entity/storage.hpp"
 
// #include "entity/utility.hpp"
 
// #include "entity/view.hpp"
 
// #include "locator/locator.hpp"
#ifndef ENTT_LOCATOR_LOCATOR_HPP
#define ENTT_LOCATOR_LOCATOR_HPP
 
 
#include <memory>
#include <utility>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
template<typename Service>
struct service_locator {
    using service_type = Service;
 
    service_locator() = delete;
    ~service_locator() = delete;
 
    static bool empty() ENTT_NOEXCEPT {
        return !static_cast<bool>(service);
    }
 
    static std::weak_ptr<Service> get() ENTT_NOEXCEPT {
        return service;
    }
 
    static Service & ref() ENTT_NOEXCEPT {
        return *service;
    }
 
    template<typename Impl = Service, typename... Args>
    static void set(Args &&... args) {
        service = std::make_shared<Impl>(std::forward<Args>(args)...);
    }
 
    static void set(std::shared_ptr<Service> ptr) {
        ENTT_ASSERT(static_cast<bool>(ptr));
        service = std::move(ptr);
    }
 
    static void reset() {
        service.reset();
    }
 
private:
    inline static std::shared_ptr<Service> service = nullptr;
};
 
 
}
 
 
#endif // ENTT_LOCATOR_LOCATOR_HPP
 
// #include "meta/factory.hpp"
#ifndef ENTT_META_FACTORY_HPP
#define ENTT_META_FACTORY_HPP
 
 
#include <tuple>
#include <array>
#include <cstddef>
#include <utility>
#include <functional>
#include <type_traits>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
// #include "../core/type_traits.hpp"
#ifndef ENTT_CORE_TYPE_TRAITS_HPP
#define ENTT_CORE_TYPE_TRAITS_HPP
 
 
#include <cstddef>
#include <type_traits>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
// #include "../core/hashed_string.hpp"
#ifndef ENTT_CORE_HASHED_STRING_HPP
#define ENTT_CORE_HASHED_STRING_HPP
 
 
#include <cstddef>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
namespace internal {
 
 
template<typename>
struct fnv1a_traits;
 
 
template<>
struct fnv1a_traits<std::uint32_t> {
    static constexpr std::uint32_t offset = 2166136261;
    static constexpr std::uint32_t prime = 16777619;
};
 
 
template<>
struct fnv1a_traits<std::uint64_t> {
    static constexpr std::uint64_t offset = 14695981039346656037ull;
    static constexpr std::uint64_t prime = 1099511628211ull;
};
 
 
}
 
 
template<typename Char>
class basic_hashed_string {
    using traits_type = internal::fnv1a_traits<ENTT_ID_TYPE>;
 
    struct const_wrapper {
        // non-explicit constructor on purpose
        constexpr const_wrapper(const Char *curr) ENTT_NOEXCEPT: str{curr} {}
        const Char *str;
    };
 
    // Fowler–Noll–Vo hash function v. 1a - the good
    static constexpr ENTT_ID_TYPE helper(ENTT_ID_TYPE partial, const Char *curr) ENTT_NOEXCEPT {
        return curr[0] == 0 ? partial : helper((partial^curr[0])*traits_type::prime, curr+1);
    }
 
public:
    using value_type = Char;
    using hash_type = ENTT_ID_TYPE;
 
    template<std::size_t N>
    static constexpr hash_type to_value(const value_type (&str)[N]) ENTT_NOEXCEPT {
        return helper(traits_type::offset, str);
    }
 
    static hash_type to_value(const_wrapper wrapper) ENTT_NOEXCEPT {
        return helper(traits_type::offset, wrapper.str);
    }
 
    static hash_type to_value(const value_type *str, std::size_t size) ENTT_NOEXCEPT {
        ENTT_ID_TYPE partial{traits_type::offset};
        while(size--) { partial = (partial^(str++)[0])*traits_type::prime; }
        return partial;
    }
 
    constexpr basic_hashed_string() ENTT_NOEXCEPT
        : str{nullptr}, hash{}
    {}
 
    template<std::size_t N>
    constexpr basic_hashed_string(const value_type (&curr)[N]) ENTT_NOEXCEPT
        : str{curr}, hash{helper(traits_type::offset, curr)}
    {}
 
    explicit constexpr basic_hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT
        : str{wrapper.str}, hash{helper(traits_type::offset, wrapper.str)}
    {}
 
    constexpr const value_type * data() const ENTT_NOEXCEPT {
        return str;
    }
 
    constexpr hash_type value() const ENTT_NOEXCEPT {
        return hash;
    }
 
    constexpr operator const value_type *() const ENTT_NOEXCEPT { return str; }
 
    constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
 
    constexpr bool operator==(const basic_hashed_string &other) const ENTT_NOEXCEPT {
        return hash == other.hash;
    }
 
private:
    const value_type *str;
    hash_type hash;
};
 
 
template<typename Char, std::size_t N>
basic_hashed_string(const Char (&str)[N]) ENTT_NOEXCEPT
-> basic_hashed_string<Char>;
 
 
template<typename Char>
constexpr bool operator!=(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
using hashed_string = basic_hashed_string<char>;
 
 
using hashed_wstring = basic_hashed_string<wchar_t>;
 
 
}
 
 
constexpr entt::hashed_string operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_string{str};
}
 
 
constexpr entt::hashed_wstring operator"" ENTT_HWS_SUFFIX(const wchar_t *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_wstring{str};
}
 
 
#endif // ENTT_CORE_HASHED_STRING_HPP
 
 
 
namespace entt {
 
 
template<std::size_t N>
struct choice_t
        // Unfortunately, doxygen cannot parse such a construct.
        : choice_t<N-1>
{};
 
 
template<>
struct choice_t<0> {};
 
 
template<std::size_t N>
constexpr choice_t<N> choice{};
 
 
template<typename...>
struct type_list {};
 
 
template<typename>
struct type_list_size;
 
 
template<typename... Type>
struct type_list_size<type_list<Type...>>
        : std::integral_constant<std::size_t, sizeof...(Type)>
{};
 
 
template<class List>
constexpr auto type_list_size_v = type_list_size<List>::value;
 
 
template<typename...>
struct type_list_cat;
 
 
template<>
struct type_list_cat<> {
    using type = type_list<>;
};
 
 
template<typename... Type, typename... Other, typename... List>
struct type_list_cat<type_list<Type...>, type_list<Other...>, List...> {
    using type = typename type_list_cat<type_list<Type..., Other...>, List...>::type;
};
 
 
template<typename... Type>
struct type_list_cat<type_list<Type...>> {
    using type = type_list<Type...>;
};
 
 
template<typename... List>
using type_list_cat_t = typename type_list_cat<List...>::type;
 
 
template<typename>
struct type_list_unique;
 
 
template<typename Type, typename... Other>
struct type_list_unique<type_list<Type, Other...>> {
    using type = std::conditional_t<
        std::disjunction_v<std::is_same<Type, Other>...>,
        typename type_list_unique<type_list<Other...>>::type,
        type_list_cat_t<type_list<Type>, typename type_list_unique<type_list<Other...>>::type>
    >;
};
 
 
template<>
struct type_list_unique<type_list<>> {
    using type = type_list<>;
};
 
 
template<typename Type>
using type_list_unique_t = typename type_list_unique<Type>::type;
 
 
template<typename Type, typename = std::void_t<>>
struct is_equality_comparable: std::false_type {};
 
 
template<typename Type>
struct is_equality_comparable<Type, std::void_t<decltype(std::declval<Type>() == std::declval<Type>())>>: std::true_type {};
 
 
template<class Type>
constexpr auto is_equality_comparable_v = is_equality_comparable<Type>::value;
 
 
template<typename>
struct named_type_traits;
 
 
template<typename Type>
struct named_type_traits<const Type>
        : named_type_traits<Type>
{};
 
 
template<typename Type>
using named_type_traits_t = typename named_type_traits<Type>::type;
 
 
template<class Type>
constexpr auto named_type_traits_v = named_type_traits<Type>::value;
 
 
template<typename Type, typename = std::void_t<>>
struct is_named_type: std::false_type {};
 
 
template<typename Type>
struct is_named_type<Type, std::void_t<named_type_traits_t<std::decay_t<Type>>>>: std::true_type {};
 
 
template<class Type>
constexpr auto is_named_type_v = is_named_type<Type>::value;
 
 
#define ENTT_OPAQUE_TYPE(clazz, type)\
    enum class clazz: type {};\
    constexpr auto to_integer(const clazz id) ENTT_NOEXCEPT {\
        return std::underlying_type_t<clazz>(id);\
    }\
    static_assert(true)
 
 
}
 
 
#define ENTT_EXPAND(args) args
 
 
#define ENTT_NAMED_TYPE(type)\
    template<>\
    struct entt::named_type_traits<type>\
        : std::integral_constant<ENTT_ID_TYPE, entt::basic_hashed_string<std::remove_cv_t<std::remove_pointer_t<std::decay_t<decltype(#type)>>>>{#type}>\
    {\
        static_assert(std::is_same_v<std::remove_cv_t<type>, type>);\
        static_assert(std::is_object_v<type>);\
    }
 
 
#define ENTT_NAMED_STRUCT_ONLY(clazz, body)\
    struct clazz body;\
    ENTT_NAMED_TYPE(clazz)
 
 
#define ENTT_NAMED_STRUCT_WITH_NAMESPACE(ns, clazz, body)\
    namespace ns { struct clazz body; }\
    ENTT_NAMED_TYPE(ns::clazz)
 
 
#define ENTT_NAMED_STRUCT_OVERLOAD(_1, _2, _3, FUNC, ...) FUNC
 
#define ENTT_NAMED_STRUCT(...) ENTT_EXPAND(ENTT_NAMED_STRUCT_OVERLOAD(__VA_ARGS__, ENTT_NAMED_STRUCT_WITH_NAMESPACE, ENTT_NAMED_STRUCT_ONLY,)(__VA_ARGS__))
 
 
#define ENTT_NAMED_CLASS_ONLY(clazz, body)\
    class clazz body;\
    ENTT_NAMED_TYPE(clazz)
 
 
#define ENTT_NAMED_CLASS_WITH_NAMESPACE(ns, clazz, body)\
    namespace ns { class clazz body; }\
    ENTT_NAMED_TYPE(ns::clazz)
 
 
#define ENTT_NAMED_CLASS_MACRO(_1, _2, _3, FUNC, ...) FUNC
 
#define ENTT_NAMED_CLASS(...) ENTT_EXPAND(ENTT_NAMED_CLASS_MACRO(__VA_ARGS__, ENTT_NAMED_CLASS_WITH_NAMESPACE, ENTT_NAMED_CLASS_ONLY,)(__VA_ARGS__))
 
 
#endif // ENTT_CORE_TYPE_TRAITS_HPP
 
// #include "policy.hpp"
#ifndef ENTT_META_POLICY_HPP
#define ENTT_META_POLICY_HPP
 
 
namespace entt {
 
 
struct as_alias_t {};
 
 
constexpr as_alias_t as_alias;
 
 
struct as_is_t {};
 
 
struct as_void_t {};
 
 
}
 
 
#endif // ENTT_META_POLICY_HPP
 
// #include "meta.hpp"
#ifndef ENTT_META_META_HPP
#define ENTT_META_META_HPP
 
 
#include <array>
#include <memory>
#include <cstddef>
#include <utility>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/type_traits.hpp"
 
// #include "../core/utility.hpp"
#ifndef ENTT_CORE_UTILITY_HPP
#define ENTT_CORE_UTILITY_HPP
 
 
// #include "../config/config.h"
 
 
 
namespace entt {
 
 
struct identity {
    template<class Type>
    constexpr Type && operator()(Type &&value) const ENTT_NOEXCEPT {
        return std::forward<Type>(value);
    }
};
 
 
template<typename Type, typename Class>
constexpr auto overload(Type Class:: *member) ENTT_NOEXCEPT { return member; }
 
 
template<typename Type>
constexpr auto overload(Type *func) ENTT_NOEXCEPT { return func; }
 
 
template<class... Func>
struct overloaded: Func... {
    using Func::operator()...;
};
 
 
template<class... Type>
overloaded(Type...) -> overloaded<Type...>;
 
 
template<class Func>
struct y_combinator {
    y_combinator(Func recursive):
        func{std::move(recursive)}
    {}
 
    template <class... Args>
    decltype(auto) operator()(Args &&... args) const {
        return func(*this, std::forward<Args>(args)...);
    }
 
    template <class... Args>
    decltype(auto) operator()(Args &&... args) {
        return func(*this, std::forward<Args>(args)...);
    }
 
private:
    Func func;
};
 
 
}
 
 
#endif // ENTT_CORE_UTILITY_HPP
 
 
 
namespace entt {
 
 
class meta_any;
class meta_handle;
class meta_type;
 
 
namespace internal {
 
 
struct meta_type_node;
 
 
struct meta_prop_node {
    meta_prop_node * next;
    meta_any(* const key)();
    meta_any(* const value)();
};
 
 
struct meta_base_node {
    meta_type_node * const parent;
    meta_base_node * next;
    meta_type_node *(* const type)() ENTT_NOEXCEPT;
    void *(* const cast)(void *) ENTT_NOEXCEPT;
};
 
 
struct meta_conv_node {
    meta_type_node * const parent;
    meta_conv_node * next;
    meta_type_node *(* const type)() ENTT_NOEXCEPT;
    meta_any(* const conv)(const void *);
};
 
 
struct meta_ctor_node {
    using size_type = std::size_t;
    meta_type_node * const parent;
    meta_ctor_node * next;
    meta_prop_node * prop;
    const size_type size;
    meta_type_node *(* const arg)(size_type) ENTT_NOEXCEPT;
    meta_any(* const invoke)(meta_any * const);
};
 
 
struct meta_dtor_node {
    meta_type_node * const parent;
    bool(* const invoke)(meta_handle);
};
 
 
struct meta_data_node {
    ENTT_ID_TYPE identifier;
    meta_type_node * const parent;
    meta_data_node * next;
    meta_prop_node * prop;
    const bool is_const;
    const bool is_static;
    meta_type_node *(* const type)() ENTT_NOEXCEPT;
    bool(* const set)(meta_handle, meta_any, meta_any);
    meta_any(* const get)(meta_handle, meta_any);
};
 
 
struct meta_func_node {
    using size_type = std::size_t;
    ENTT_ID_TYPE identifier;
    meta_type_node * const parent;
    meta_func_node * next;
    meta_prop_node * prop;
    const size_type size;
    const bool is_const;
    const bool is_static;
    meta_type_node *(* const ret)() ENTT_NOEXCEPT;
    meta_type_node *(* const arg)(size_type) ENTT_NOEXCEPT;
    meta_any(* const invoke)(meta_handle, meta_any *);
};
 
 
struct meta_type_node {
    using size_type = std::size_t;
    ENTT_ID_TYPE identifier;
    meta_type_node * next;
    meta_prop_node * prop;
    const bool is_void;
    const bool is_integral;
    const bool is_floating_point;
    const bool is_array;
    const bool is_enum;
    const bool is_union;
    const bool is_class;
    const bool is_pointer;
    const bool is_function_pointer;
    const bool is_member_object_pointer;
    const bool is_member_function_pointer;
    const size_type extent;
    bool(* const compare)(const void *, const void *);
    meta_type_node *(* const remove_pointer)() ENTT_NOEXCEPT;
    meta_type_node *(* const remove_extent)() ENTT_NOEXCEPT;
    meta_base_node *base{nullptr};
    meta_conv_node *conv{nullptr};
    meta_ctor_node *ctor{nullptr};
    meta_dtor_node *dtor{nullptr};
    meta_data_node *data{nullptr};
    meta_func_node *func{nullptr};
};
 
 
template<typename Type, typename Op, typename Node>
void iterate(Op op, Node *curr) ENTT_NOEXCEPT {
    while(curr) {
        op(Type{curr});
        curr = curr->next;
    }
}
 
 
template<auto Member, typename Type, typename Op>
void iterate(Op op, const meta_type_node *node) ENTT_NOEXCEPT {
    if(node) {
        auto *curr = node->base;
        iterate<Type>(op, node->*Member);
 
        while(curr) {
            iterate<Member, Type>(op, curr->type());
            curr = curr->next;
        }
    }
}
 
 
template<typename Op, typename Node>
auto find_if(Op op, Node *curr) ENTT_NOEXCEPT {
    while(curr && !op(curr)) {
        curr = curr->next;
    }
 
    return curr;
}
 
 
template<auto Member, typename Op>
auto find_if(Op op, const meta_type_node *node) ENTT_NOEXCEPT
-> decltype(find_if(op, node->*Member)) {
    decltype(find_if(op, node->*Member)) ret = nullptr;
 
    if(node) {
        ret = find_if(op, node->*Member);
        auto *curr = node->base;
 
        while(curr && !ret) {
            ret = find_if<Member>(op, curr->type());
            curr = curr->next;
        }
    }
 
    return ret;
}
 
 
template<typename Type>
static bool compare(const void *lhs, const void *rhs) {
    if constexpr(!std::is_function_v<Type> && is_equality_comparable_v<Type>) {
        return *static_cast<const Type *>(lhs) == *static_cast<const Type *>(rhs);
    } else {
        return lhs == rhs;
    }
}
 
 
template<typename...>
struct meta_node;
 
 
template<>
struct meta_node<> {
    inline static meta_type_node *local = nullptr;
    inline static meta_type_node **global = &local;
};
 
 
template<typename Type>
struct meta_node<Type> {
    static_assert(std::is_same_v<Type, std::remove_cv_t<std::remove_reference_t<Type>>>);
 
    static void reset() ENTT_NOEXCEPT {
        auto * const node = resolve();
        auto **it = meta_node<>::global;
 
        while(*it && *it != node) {
            it = &(*it)->next;
        }
 
        if(*it) {
            *it = (*it)->next;
        }
 
        const auto unregister_all = y_combinator{
            [](auto &&self, auto **curr, auto... member) {
                while(*curr) {
                    auto *prev = *curr;
                    (self(&(prev->*member)), ...);
                    *curr = prev->next;
                    prev->next = nullptr;
                }
            }
        };
 
        unregister_all(&node->prop);
        unregister_all(&node->base);
        unregister_all(&node->conv);
        unregister_all(&node->ctor, &internal::meta_ctor_node::prop);
        unregister_all(&node->data, &internal::meta_data_node::prop);
        unregister_all(&node->func, &internal::meta_func_node::prop);
 
        node->identifier = {};
        node->dtor = nullptr;
        node->next = nullptr;
    }
 
    static meta_type_node * resolve() ENTT_NOEXCEPT {
        static meta_type_node node{
            {},
            nullptr,
            nullptr,
            std::is_void_v<Type>,
            std::is_integral_v<Type>,
            std::is_floating_point_v<Type>,
            std::is_array_v<Type>,
            std::is_enum_v<Type>,
            std::is_union_v<Type>,
            std::is_class_v<Type>,
            std::is_pointer_v<Type>,
            std::is_pointer_v<Type> && std::is_function_v<std::remove_pointer_t<Type>>,
            std::is_member_object_pointer_v<Type>,
            std::is_member_function_pointer_v<Type>,
            std::extent_v<Type>,
            &compare<Type>, // workaround for an issue with VS2017
            []() ENTT_NOEXCEPT -> meta_type_node * {
                return meta_node<std::remove_const_t<std::remove_pointer_t<Type>>>::resolve();
            },
            []() ENTT_NOEXCEPT -> meta_type_node * {
                return meta_node<std::remove_const_t<std::remove_extent_t<Type>>>::resolve();
            }
        };
 
        if constexpr(is_named_type_v<Type>) {
            auto *candidate = internal::find_if([](auto *curr) {
                return curr->identifier == named_type_traits_v<Type>;
            }, *meta_node<>::global);
 
            return candidate ? candidate : &node;
        } else {
            return &node;
        }
    }
};
 
 
template<typename... Type>
struct meta_info: meta_node<std::remove_cv_t<std::remove_reference_t<Type>>...> {};
 
 
}
 
 
class meta_any {
    friend class meta_handle;
 
    using storage_type = std::aligned_storage_t<sizeof(void *), alignof(void *)>;
    using copy_fn_type = void *(storage_type &, const void *);
    using destroy_fn_type = void(void *);
    using steal_fn_type = void *(storage_type &, void *, destroy_fn_type *);
 
    template<typename Type>
    static Type * release(Type *instance) {
        const auto * const node = internal::meta_info<Type>::resolve();
        [[maybe_unused]] const bool destroyed = (!node->dtor || node->dtor->invoke(*instance));
        ENTT_ASSERT(destroyed);
        return instance;
    }
 
    template<typename Type, typename = std::void_t<>>
    struct type_traits {
        template<typename... Args>
        static void * instance(storage_type &storage, Args &&... args) {
            auto instance = std::make_unique<Type>(std::forward<Args>(args)...);
            new (&storage) Type *{instance.get()};
            return instance.release();
        }
 
        static void destroy(void *instance) {
            delete release<Type>(static_cast<Type *>(instance));
        }
 
        static void * copy(storage_type &storage, const void *other) {
            auto instance = std::make_unique<Type>(*static_cast<const Type *>(other));
            new (&storage) Type *{instance.get()};
            return instance.release();
        }
 
        static void * steal(storage_type &to, void *from, destroy_fn_type *) {
            auto * const instance = static_cast<Type *>(from);
            new (&to) Type *{instance};
            return instance;
        }
    };
 
    template<typename Type>
    struct type_traits<Type, std::enable_if_t<sizeof(Type) <= sizeof(void *) && std::is_nothrow_move_constructible_v<Type>>> {
        template<typename... Args>
        static void * instance(storage_type &storage, Args &&... args) {
            return new (&storage) Type{std::forward<Args>(args)...};
        }
 
        static void destroy(void *instance) {
            release<Type>(static_cast<Type *>(instance))->~Type();
        }
 
        static void * copy(storage_type &storage, const void *instance) {
            return new (&storage) Type{*static_cast<const Type *>(instance)};
        }
 
        static void * steal(storage_type &to, void *from, destroy_fn_type *destroy_fn) {
            void * const instance = new (&to) Type{std::move(*static_cast<Type *>(from))};
            destroy_fn(from);
            return instance;
        }
    };
 
public:
    meta_any() ENTT_NOEXCEPT
        : storage{},
          instance{nullptr},
          node{nullptr},
          destroy_fn{nullptr},
          copy_fn{nullptr},
          steal_fn{nullptr}
    {}
 
    template<typename Type, typename... Args>
    explicit meta_any(std::in_place_type_t<Type>, [[maybe_unused]] Args &&... args)
        : meta_any{}
    {
        node = internal::meta_info<Type>::resolve();
 
        if constexpr(!std::is_void_v<Type>) {
            using traits_type = type_traits<std::remove_cv_t<std::remove_reference_t<Type>>>;
            static_assert(std::is_copy_constructible_v<Type>);
 
            instance = traits_type::instance(storage, std::forward<Args>(args)...);
            destroy_fn = &traits_type::destroy;
            copy_fn = &traits_type::copy;
            steal_fn = &traits_type::steal;
        }
    }
 
    template<typename Type>
    explicit meta_any(std::reference_wrapper<Type> type)
        : meta_any{}
    {
        node = internal::meta_info<Type>::resolve();
        instance = &type.get();
    }
 
    inline meta_any(meta_handle handle) ENTT_NOEXCEPT;
 
    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_any>>>
    meta_any(Type &&type)
        : meta_any{std::in_place_type<std::remove_cv_t<std::remove_reference_t<Type>>>, std::forward<Type>(type)}
    {}
 
    meta_any(const meta_any &other)
        : meta_any{}
    {
        node = other.node;
        instance = other.copy_fn ? other.copy_fn(storage, other.instance) : other.instance;
        destroy_fn = other.destroy_fn;
        copy_fn = other.copy_fn;
        steal_fn = other.steal_fn;
    }
 
    meta_any(meta_any &&other) ENTT_NOEXCEPT
        : meta_any{}
    {
        swap(*this, other);
    }
 
    ~meta_any() {
        if(destroy_fn) {
            destroy_fn(instance);
        }
    }
 
    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_any>>>
    meta_any & operator=(Type &&type) {
        return (*this = meta_any{std::forward<Type>(type)});
    }
 
    meta_any & operator=(const meta_any &other) {
        return (*this = meta_any{other});
    }
 
    meta_any & operator=(meta_any &&other) ENTT_NOEXCEPT {
        meta_any any{std::move(other)};
        swap(any, *this);
        return *this;
    }
 
    inline meta_type type() const ENTT_NOEXCEPT;
 
    const void * data() const ENTT_NOEXCEPT {
        return instance;
    }
 
    void * data() ENTT_NOEXCEPT {
        return const_cast<void *>(std::as_const(*this).data());
    }
 
    template<typename Type>
    const Type * try_cast() const ENTT_NOEXCEPT {
        const auto * const type = internal::meta_info<Type>::resolve();
        void *ret = nullptr;
 
        if(node == type) {
            ret = instance;
        } else {
            const auto *base = internal::find_if<&internal::meta_type_node::base>([type](auto *candidate) {
                return candidate->type() == type;
            }, node);
 
            ret = base ? base->cast(instance) : nullptr;
        }
 
        return static_cast<const Type *>(ret);
    }
 
    template<typename Type>
    Type * try_cast() ENTT_NOEXCEPT {
        return const_cast<Type *>(std::as_const(*this).try_cast<Type>());
    }
 
    template<typename Type>
    const Type & cast() const ENTT_NOEXCEPT {
        auto * const actual = try_cast<Type>();
        ENTT_ASSERT(actual);
        return *actual;
    }
 
    template<typename Type>
    Type & cast() ENTT_NOEXCEPT {
        return const_cast<Type &>(std::as_const(*this).cast<Type>());
    }
 
    template<typename Type>
    meta_any convert() const {
        meta_any any{};
 
        if(const auto * const type = internal::meta_info<Type>::resolve(); node == type) {
            any = *static_cast<const Type *>(instance);
        } else {
            const auto * const conv = internal::find_if<&internal::meta_type_node::conv>([type](auto *other) {
                return other->type() == type;
            }, node);
 
            if(conv) {
                any = conv->conv(instance);
            }
        }
 
        return any;
    }
 
    template<typename Type>
    bool convert() {
        bool valid = (node == internal::meta_info<Type>::resolve());
 
        if(!valid) {
            if(auto any = std::as_const(*this).convert<Type>(); any) {
                swap(any, *this);
                valid = true;
            }
        }
 
        return valid;
    }
 
    template<typename Type, typename... Args>
    void emplace(Args &&... args) {
        *this = meta_any{std::in_place_type_t<Type>{}, std::forward<Args>(args)...};
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return node;
    }
 
    bool operator==(const meta_any &other) const ENTT_NOEXCEPT {
        return node == other.node && (!node || node->compare(instance, other.instance));
    }
 
    friend void swap(meta_any &lhs, meta_any &rhs) ENTT_NOEXCEPT {
        if(lhs.steal_fn && rhs.steal_fn) {
            storage_type buffer;
            auto * const temp = lhs.steal_fn(buffer, lhs.instance, lhs.destroy_fn);
            lhs.instance = rhs.steal_fn(lhs.storage, rhs.instance, rhs.destroy_fn);
            rhs.instance = lhs.steal_fn(rhs.storage, temp, lhs.destroy_fn);
        } else if(lhs.steal_fn) {
            lhs.instance = lhs.steal_fn(rhs.storage, lhs.instance, lhs.destroy_fn);
            std::swap(rhs.instance, lhs.instance);
        } else if(rhs.steal_fn) {
            rhs.instance = rhs.steal_fn(lhs.storage, rhs.instance, rhs.destroy_fn);
            std::swap(rhs.instance, lhs.instance);
        } else {
            std::swap(lhs.instance, rhs.instance);
        }
 
        std::swap(lhs.node, rhs.node);
        std::swap(lhs.destroy_fn, rhs.destroy_fn);
        std::swap(lhs.copy_fn, rhs.copy_fn);
        std::swap(lhs.steal_fn, rhs.steal_fn);
    }
 
private:
    storage_type storage;
    void *instance;
    const internal::meta_type_node *node;
    destroy_fn_type *destroy_fn;
    copy_fn_type *copy_fn;
    steal_fn_type *steal_fn;
};
 
 
class meta_handle {
    friend class meta_any;
 
public:
    meta_handle() ENTT_NOEXCEPT
        : node{nullptr},
          instance{nullptr}
    {}
 
    meta_handle(meta_any &any) ENTT_NOEXCEPT
        : node{any.node},
          instance{any.instance}
    {}
 
    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, meta_handle>>>
    meta_handle(Type &obj) ENTT_NOEXCEPT
        : node{internal::meta_info<Type>::resolve()},
          instance{&obj}
    {}
 
    inline meta_type type() const ENTT_NOEXCEPT;
 
    const void * data() const ENTT_NOEXCEPT {
        return instance;
    }
 
    void * data() ENTT_NOEXCEPT {
        return const_cast<void *>(std::as_const(*this).data());
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return instance;
    }
 
private:
    const internal::meta_type_node *node;
    void *instance;
};
 
 
inline bool operator!=(const meta_any &lhs, const meta_any &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
struct meta_prop {
    meta_prop(const internal::meta_prop_node *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    meta_any key() const ENTT_NOEXCEPT {
        return node->key();
    }
 
    meta_any value() const ENTT_NOEXCEPT {
        return node->value();
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return node;
    }
 
    bool operator==(const meta_prop &other) const ENTT_NOEXCEPT {
        return node == other.node;
    }
 
private:
    const internal::meta_prop_node *node;
};
 
 
inline bool operator!=(const meta_prop &lhs, const meta_prop &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
struct meta_base {
    meta_base(const internal::meta_base_node *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    inline meta_type parent() const ENTT_NOEXCEPT;
 
    inline meta_type type() const ENTT_NOEXCEPT;
 
    void * cast(void *instance) const ENTT_NOEXCEPT {
        return node->cast(instance);
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return node;
    }
 
    bool operator==(const meta_base &other) const ENTT_NOEXCEPT {
        return node == other.node;
    }
 
private:
    const internal::meta_base_node *node;
};
 
 
inline bool operator!=(const meta_base &lhs, const meta_base &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
struct meta_conv {
    meta_conv(const internal::meta_conv_node *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    inline meta_type parent() const ENTT_NOEXCEPT;
 
    inline meta_type type() const ENTT_NOEXCEPT;
 
    meta_any convert(const void *instance) const ENTT_NOEXCEPT {
        return node->conv(instance);
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return node;
    }
 
    bool operator==(const meta_conv &other) const ENTT_NOEXCEPT {
        return node == other.node;
    }
 
private:
    const internal::meta_conv_node *node;
};
 
 
inline bool operator!=(const meta_conv &lhs, const meta_conv &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
struct meta_ctor {
    using size_type = typename internal::meta_ctor_node::size_type;
 
    meta_ctor(const internal::meta_ctor_node *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    inline meta_type parent() const ENTT_NOEXCEPT;
 
    size_type size() const ENTT_NOEXCEPT {
        return node->size;
    }
 
    meta_type arg(size_type index) const ENTT_NOEXCEPT;
 
    template<typename... Args>
    meta_any invoke(Args &&... args) const {
        std::array<meta_any, sizeof...(Args)> arguments{{std::forward<Args>(args)...}};
        meta_any any{};
 
        if(sizeof...(Args) == size()) {
            any = node->invoke(arguments.data());
        }
 
        return any;
    }
 
    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void>
    prop(Op op) const ENTT_NOEXCEPT {
        internal::iterate<meta_prop>(std::move(op), node->prop);
    }
 
    meta_prop prop(meta_any key) const ENTT_NOEXCEPT {
        return internal::find_if([key = std::move(key)](auto *candidate) {
            return candidate->key() == key;
        }, node->prop);
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return node;
    }
 
    bool operator==(const meta_ctor &other) const ENTT_NOEXCEPT {
        return node == other.node;
    }
 
private:
    const internal::meta_ctor_node *node;
};
 
 
inline bool operator!=(const meta_ctor &lhs, const meta_ctor &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
struct meta_dtor {
    meta_dtor(const internal::meta_dtor_node *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    inline meta_type parent() const ENTT_NOEXCEPT;
 
    bool invoke(meta_handle handle) const {
        return node->invoke(handle);
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return node;
    }
 
    bool operator==(const meta_dtor &other) const ENTT_NOEXCEPT {
        return node == other.node;
    }
 
private:
    const internal::meta_dtor_node *node;
};
 
 
inline bool operator!=(const meta_dtor &lhs, const meta_dtor &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
struct meta_data {
    meta_data(const internal::meta_data_node *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    ENTT_ID_TYPE identifier() const ENTT_NOEXCEPT {
        return node->identifier;
    }
 
    inline meta_type parent() const ENTT_NOEXCEPT;
 
    bool is_const() const ENTT_NOEXCEPT {
        return node->is_const;
    }
 
    bool is_static() const ENTT_NOEXCEPT {
        return node->is_static;
    }
 
    inline meta_type type() const ENTT_NOEXCEPT;
 
    template<typename Type>
    bool set(meta_handle handle, Type &&value) const {
        return node->set(handle, meta_any{}, std::forward<Type>(value));
    }
 
    template<typename Type>
    bool set(meta_handle handle, std::size_t index, Type &&value) const {
        ENTT_ASSERT(index < node->type()->extent);
        return node->set(handle, index, std::forward<Type>(value));
    }
 
    meta_any get(meta_handle handle) const ENTT_NOEXCEPT {
        return node->get(handle, meta_any{});
    }
 
    meta_any get(meta_handle handle, std::size_t index) const ENTT_NOEXCEPT {
        ENTT_ASSERT(index < node->type()->extent);
        return node->get(handle, index);
    }
 
    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void>
    prop(Op op) const ENTT_NOEXCEPT {
        internal::iterate<meta_prop>(std::move(op), node->prop);
    }
 
    meta_prop prop(meta_any key) const ENTT_NOEXCEPT {
        return internal::find_if([key = std::move(key)](auto *candidate) {
            return candidate->key() == key;
        }, node->prop);
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return node;
    }
 
    bool operator==(const meta_data &other) const ENTT_NOEXCEPT {
        return node == other.node;
    }
 
private:
    const internal::meta_data_node *node;
};
 
 
inline bool operator!=(const meta_data &lhs, const meta_data &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
struct meta_func {
    using size_type = typename internal::meta_func_node::size_type;
 
    meta_func(const internal::meta_func_node *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    ENTT_ID_TYPE identifier() const ENTT_NOEXCEPT {
        return node->identifier;
    }
 
    inline meta_type parent() const ENTT_NOEXCEPT;
 
    size_type size() const ENTT_NOEXCEPT {
        return node->size;
    }
 
    bool is_const() const ENTT_NOEXCEPT {
        return node->is_const;
    }
 
    bool is_static() const ENTT_NOEXCEPT {
        return node->is_static;
    }
 
    inline meta_type ret() const ENTT_NOEXCEPT;
 
    inline meta_type arg(size_type index) const ENTT_NOEXCEPT;
 
    template<typename... Args>
    meta_any invoke(meta_handle handle, Args &&... args) const {
        // makes aliasing on the values and passes forward references if any
        std::array<meta_any, sizeof...(Args)> arguments{{meta_handle{args}...}};
        meta_any any{};
 
        if(sizeof...(Args) == size()) {
            any = node->invoke(handle, arguments.data());
        }
 
        return any;
    }
 
    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void>
    prop(Op op) const ENTT_NOEXCEPT {
        internal::iterate<meta_prop>(std::move(op), node->prop);
    }
 
    meta_prop prop(meta_any key) const ENTT_NOEXCEPT {
        return internal::find_if([key = std::move(key)](auto *candidate) {
            return candidate->key() == key;
        }, node->prop);
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return node;
    }
 
    bool operator==(const meta_func &other) const ENTT_NOEXCEPT {
        return node == other.node;
    }
 
private:
    const internal::meta_func_node *node;
};
 
 
inline bool operator!=(const meta_func &lhs, const meta_func &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
class meta_type {
    template<typename... Args, std::size_t... Indexes>
    auto ctor(std::index_sequence<Indexes...>) const ENTT_NOEXCEPT {
        return internal::find_if([](auto *candidate) {
            return candidate->size == sizeof...(Args) && ([](auto *from, auto *to) {
                return (from == to) || internal::find_if<&internal::meta_type_node::base>([to](auto *curr) { return curr->type() == to; }, from)
                        || internal::find_if<&internal::meta_type_node::conv>([to](auto *curr) { return curr->type() == to; }, from);
            }(internal::meta_info<Args>::resolve(), candidate->arg(Indexes)) && ...);
        }, node->ctor);
    }
 
public:
    using size_type = typename internal::meta_type_node::size_type;
 
    meta_type(const internal::meta_type_node *curr = nullptr) ENTT_NOEXCEPT
        : node{curr}
    {}
 
    ENTT_ID_TYPE identifier() const ENTT_NOEXCEPT {
        return node->identifier;
    }
 
    bool is_void() const ENTT_NOEXCEPT {
        return node->is_void;
    }
 
    bool is_integral() const ENTT_NOEXCEPT {
        return node->is_integral;
    }
 
    bool is_floating_point() const ENTT_NOEXCEPT {
        return node->is_floating_point;
    }
 
    bool is_array() const ENTT_NOEXCEPT {
        return node->is_array;
    }
 
    bool is_enum() const ENTT_NOEXCEPT {
        return node->is_enum;
    }
 
    bool is_union() const ENTT_NOEXCEPT {
        return node->is_union;
    }
 
    bool is_class() const ENTT_NOEXCEPT {
        return node->is_class;
    }
 
    bool is_pointer() const ENTT_NOEXCEPT {
        return node->is_pointer;
    }
 
    bool is_function_pointer() const ENTT_NOEXCEPT {
        return node->is_function_pointer;
    }
 
    bool is_member_object_pointer() const ENTT_NOEXCEPT {
        return node->is_member_object_pointer;
    }
 
    bool is_member_function_pointer() const ENTT_NOEXCEPT {
        return node->is_member_function_pointer;
    }
 
    size_type extent() const ENTT_NOEXCEPT {
        return node->extent;
    }
 
    meta_type remove_pointer() const ENTT_NOEXCEPT {
        return node->remove_pointer();
    }
 
    meta_type remove_extent() const ENTT_NOEXCEPT {
        return node->remove_extent();
    }
 
    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta_base>, void>
    base(Op op) const ENTT_NOEXCEPT {
        internal::iterate<&internal::meta_type_node::base, meta_base>(std::move(op), node);
    }
 
    meta_base base(const ENTT_ID_TYPE identifier) const ENTT_NOEXCEPT {
        return internal::find_if<&internal::meta_type_node::base>([identifier](auto *candidate) {
            return candidate->type()->identifier == identifier;
        }, node);
    }
 
    template<typename Op>
    void conv(Op op) const ENTT_NOEXCEPT {
        internal::iterate<&internal::meta_type_node::conv, meta_conv>(std::move(op), node);
    }
 
    template<typename Type>
    meta_conv conv() const ENTT_NOEXCEPT {
        return internal::find_if<&internal::meta_type_node::conv>([type = internal::meta_info<Type>::resolve()](auto *candidate) {
            return candidate->type() == type;
        }, node);
    }
 
    template<typename Op>
    void ctor(Op op) const ENTT_NOEXCEPT {
        internal::iterate<meta_ctor>(std::move(op), node->ctor);
    }
 
    template<typename... Args>
    meta_ctor ctor() const ENTT_NOEXCEPT {
        return ctor<Args...>(std::index_sequence_for<Args...>{});
    }
 
    meta_dtor dtor() const ENTT_NOEXCEPT {
        return node->dtor;
    }
 
    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta_data>, void>
    data(Op op) const ENTT_NOEXCEPT {
        internal::iterate<&internal::meta_type_node::data, meta_data>(std::move(op), node);
    }
 
    meta_data data(const ENTT_ID_TYPE identifier) const ENTT_NOEXCEPT {
        return internal::find_if<&internal::meta_type_node::data>([identifier](auto *candidate) {
            return candidate->identifier == identifier;
        }, node);
    }
 
    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta_func>, void>
    func(Op op) const ENTT_NOEXCEPT {
        internal::iterate<&internal::meta_type_node::func, meta_func>(std::move(op), node);
    }
 
    meta_func func(const ENTT_ID_TYPE identifier) const ENTT_NOEXCEPT {
        return internal::find_if<&internal::meta_type_node::func>([identifier](auto *candidate) {
            return candidate->identifier == identifier;
        }, node);
    }
 
    template<typename... Args>
    meta_any construct(Args &&... args) const {
        std::array<meta_any, sizeof...(Args)> arguments{{std::forward<Args>(args)...}};
        meta_any any{};
 
        internal::find_if<&internal::meta_type_node::ctor>([data = arguments.data(), &any](auto *curr) -> bool {
            if(curr->size == sizeof...(args)) {
                any = curr->invoke(data);
            }
 
            return static_cast<bool>(any);
        }, node);
 
        return any;
    }
 
    bool destroy(meta_handle handle) const {
        return (handle.type() == node) && (!node->dtor || node->dtor->invoke(handle));
    }
 
    template<typename Op>
    std::enable_if_t<std::is_invocable_v<Op, meta_prop>, void>
    prop(Op op) const ENTT_NOEXCEPT {
        internal::iterate<&internal::meta_type_node::prop, meta_prop>(std::move(op), node);
    }
 
    meta_prop prop(meta_any key) const ENTT_NOEXCEPT {
        return internal::find_if<&internal::meta_type_node::prop>([key = std::move(key)](auto *candidate) {
            return candidate->key() == key;
        }, node);
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return node;
    }
 
    bool operator==(const meta_type &other) const ENTT_NOEXCEPT {
        return node == other.node;
    }
 
private:
    const internal::meta_type_node *node;
};
 
 
struct meta_ctx {
    static void bind(meta_ctx other) ENTT_NOEXCEPT {
        internal::meta_info<>::global = other.ctx;
    }
 
private:
    internal::meta_type_node **ctx{&internal::meta_info<>::local};
};
 
 
inline bool operator!=(const meta_type &lhs, const meta_type &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
inline meta_any::meta_any(meta_handle handle) ENTT_NOEXCEPT
    : meta_any{}
{
    node = handle.node;
    instance = handle.instance;
}
 
 
inline meta_type meta_any::type() const ENTT_NOEXCEPT {
    return node;
}
 
 
inline meta_type meta_handle::type() const ENTT_NOEXCEPT {
    return node;
}
 
 
inline meta_type meta_base::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
inline meta_type meta_base::type() const ENTT_NOEXCEPT {
    return node->type();
}
 
 
inline meta_type meta_conv::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
inline meta_type meta_conv::type() const ENTT_NOEXCEPT {
    return node->type();
}
 
 
inline meta_type meta_ctor::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
inline meta_type meta_ctor::arg(size_type index) const ENTT_NOEXCEPT {
    return index < size() ? node->arg(index) : nullptr;
}
 
 
inline meta_type meta_dtor::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
inline meta_type meta_data::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
inline meta_type meta_data::type() const ENTT_NOEXCEPT {
    return node->type();
}
 
 
inline meta_type meta_func::parent() const ENTT_NOEXCEPT {
    return node->parent;
}
 
 
inline meta_type meta_func::ret() const ENTT_NOEXCEPT {
    return node->ret();
}
 
 
inline meta_type meta_func::arg(size_type index) const ENTT_NOEXCEPT {
    return index < size() ? node->arg(index) : nullptr;
}
 
 
}
 
 
#endif // ENTT_META_META_HPP
 
 
 
namespace entt {
 
 
namespace internal {
 
 
template<typename>
struct meta_function_helper;
 
 
template<typename Ret, typename... Args>
struct meta_function_helper<Ret(Args...)> {
    using return_type = std::remove_cv_t<std::remove_reference_t<Ret>>;
    using args_type = std::tuple<std::remove_cv_t<std::remove_reference_t<Args>>...>;
 
    static constexpr std::index_sequence_for<Args...> index_sequence{};
    static constexpr auto is_const = false;
 
    static auto arg(typename internal::meta_func_node::size_type index) ENTT_NOEXCEPT {
        return std::array<meta_type_node *, sizeof...(Args)>{{meta_info<Args>::resolve()...}}[index];
    }
};
 
 
template<typename Ret, typename... Args>
struct meta_function_helper<Ret(Args...) const>: meta_function_helper<Ret(Args...)> {
    static constexpr auto is_const = true;
};
 
 
template<typename Ret, typename... Args, typename Class>
constexpr meta_function_helper<Ret(Args...)>
to_meta_function_helper(Ret(Class:: *)(Args...));
 
 
template<typename Ret, typename... Args, typename Class>
constexpr meta_function_helper<Ret(Args...) const>
to_meta_function_helper(Ret(Class:: *)(Args...) const);
 
 
template<typename Ret, typename... Args>
constexpr meta_function_helper<Ret(Args...)>
to_meta_function_helper(Ret(*)(Args...));
 
 
constexpr void to_meta_function_helper(...);
 
 
template<typename Candidate>
using meta_function_helper_t = decltype(to_meta_function_helper(std::declval<Candidate>()));
 
 
template<typename Type, typename... Args, std::size_t... Indexes>
meta_any construct(meta_any * const args, std::index_sequence<Indexes...>) {
    [[maybe_unused]] auto direct = std::make_tuple((args+Indexes)->try_cast<Args>()...);
    meta_any any{};
 
    if(((std::get<Indexes>(direct) || (args+Indexes)->convert<Args>()) && ...)) {
        any = Type{(std::get<Indexes>(direct) ? *std::get<Indexes>(direct) : (args+Indexes)->cast<Args>())...};
    }
 
    return any;
}
 
 
template<bool Const, typename Type, auto Data>
bool setter([[maybe_unused]] meta_handle handle, [[maybe_unused]] meta_any index, [[maybe_unused]] meta_any value) {
    bool accepted = false;
 
    if constexpr(!Const) {
        if constexpr(std::is_function_v<std::remove_reference_t<std::remove_pointer_t<decltype(Data)>>> || std::is_member_function_pointer_v<decltype(Data)>) {
            using helper_type = meta_function_helper_t<decltype(Data)>;
            using data_type = std::tuple_element_t<!std::is_member_function_pointer_v<decltype(Data)>, typename helper_type::args_type>;
            static_assert(std::is_invocable_v<decltype(Data), Type &, data_type>);
            auto * const clazz = meta_any{handle}.try_cast<Type>();
            auto * const direct = value.try_cast<data_type>();
 
            if(clazz && (direct || value.convert<data_type>())) {
                std::invoke(Data, *clazz, direct ? *direct : value.cast<data_type>());
                accepted = true;
            }
        } else if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
            using data_type = std::remove_cv_t<std::remove_reference_t<decltype(std::declval<Type>().*Data)>>;
            static_assert(std::is_invocable_v<decltype(Data), Type *>);
            auto * const clazz = meta_any{handle}.try_cast<Type>();
 
            if constexpr(std::is_array_v<data_type>) {
                using underlying_type = std::remove_extent_t<data_type>;
                auto * const direct = value.try_cast<underlying_type>();
                auto * const idx = index.try_cast<std::size_t>();
 
                if(clazz && idx && (direct || value.convert<underlying_type>())) {
                    std::invoke(Data, clazz)[*idx] = direct ? *direct : value.cast<underlying_type>();
                    accepted = true;
                }
            } else {
                auto * const direct = value.try_cast<data_type>();
 
                if(clazz && (direct || value.convert<data_type>())) {
                    std::invoke(Data, clazz) = (direct ? *direct : value.cast<data_type>());
                    accepted = true;
                }
            }
        } else {
            static_assert(std::is_pointer_v<decltype(Data)>);
            using data_type = std::remove_cv_t<std::remove_reference_t<decltype(*Data)>>;
 
            if constexpr(std::is_array_v<data_type>) {
                using underlying_type = std::remove_extent_t<data_type>;
                auto * const direct = value.try_cast<underlying_type>();
                auto * const idx = index.try_cast<std::size_t>();
 
                if(idx && (direct || value.convert<underlying_type>())) {
                    (*Data)[*idx] = (direct ? *direct : value.cast<underlying_type>());
                    accepted = true;
                }
            } else {
                auto * const direct = value.try_cast<data_type>();
 
                if(direct || value.convert<data_type>()) {
                    *Data = (direct ? *direct : value.cast<data_type>());
                    accepted = true;
                }
            }
        }
    }
 
    return accepted;
}
 
 
template<typename Type, auto Data, typename Policy>
meta_any getter([[maybe_unused]] meta_handle handle, [[maybe_unused]] meta_any index) {
    auto dispatch = [](auto &&value) {
        if constexpr(std::is_same_v<Policy, as_void_t>) {
            return meta_any{std::in_place_type<void>};
        } else if constexpr(std::is_same_v<Policy, as_alias_t>) {
            return meta_any{std::ref(std::forward<decltype(value)>(value))};
        } else {
            static_assert(std::is_same_v<Policy, as_is_t>);
            return meta_any{std::forward<decltype(value)>(value)};
        }
    };
 
    if constexpr(std::is_function_v<std::remove_reference_t<std::remove_pointer_t<decltype(Data)>>> || std::is_member_function_pointer_v<decltype(Data)>) {
        static_assert(std::is_invocable_v<decltype(Data), Type &>);
        auto * const clazz = meta_any{handle}.try_cast<Type>();
        return clazz ? dispatch(std::invoke(Data, *clazz)) : meta_any{};
    } else if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
        using data_type = std::remove_cv_t<std::remove_reference_t<decltype(std::declval<Type>().*Data)>>;
        static_assert(std::is_invocable_v<decltype(Data), Type *>);
        auto * const clazz = meta_any{handle}.try_cast<Type>();
 
        if constexpr(std::is_array_v<data_type>) {
            auto * const idx = index.try_cast<std::size_t>();
            return (clazz && idx) ? dispatch(std::invoke(Data, clazz)[*idx]) : meta_any{};
        } else {
            return clazz ? dispatch(std::invoke(Data, clazz)) : meta_any{};
        }
    } else {
        static_assert(std::is_pointer_v<std::decay_t<decltype(Data)>>);
 
        if constexpr(std::is_array_v<std::remove_pointer_t<decltype(Data)>>) {
            auto * const idx = index.try_cast<std::size_t>();
            return idx ? dispatch((*Data)[*idx]) : meta_any{};
        } else {
            return dispatch(*Data);
        }
    }
}
 
 
template<typename Type, auto Candidate, typename Policy, std::size_t... Indexes>
meta_any invoke([[maybe_unused]] meta_handle handle, meta_any *args, std::index_sequence<Indexes...>) {
    using helper_type = meta_function_helper_t<decltype(Candidate)>;
 
    auto dispatch = [](auto *... params) {
        if constexpr(std::is_void_v<typename helper_type::return_type> || std::is_same_v<Policy, as_void_t>) {
            std::invoke(Candidate, *params...);
            return meta_any{std::in_place_type<void>};
        } else if constexpr(std::is_same_v<Policy, as_alias_t>) {
            return meta_any{std::ref(std::invoke(Candidate, *params...))};
        } else {
            static_assert(std::is_same_v<Policy, as_is_t>);
            return meta_any{std::invoke(Candidate, *params...)};
        }
    };
 
    [[maybe_unused]] const auto direct = std::make_tuple([](meta_any *any, auto *instance) {
        using arg_type = std::remove_reference_t<decltype(*instance)>;
 
        if(!instance && any->convert<arg_type>()) {
            instance = any->try_cast<arg_type>();
        }
 
        return instance;
    }(args+Indexes, (args+Indexes)->try_cast<std::tuple_element_t<Indexes, typename helper_type::args_type>>())...);
 
    if constexpr(std::is_function_v<std::remove_reference_t<std::remove_pointer_t<decltype(Candidate)>>>) {
        return (std::get<Indexes>(direct) && ...) ? dispatch(std::get<Indexes>(direct)...) : meta_any{};
    } else {
        auto * const clazz = meta_any{handle}.try_cast<Type>();
        return (clazz && (std::get<Indexes>(direct) && ...)) ? dispatch(clazz, std::get<Indexes>(direct)...) : meta_any{};
    }
}
 
 
}
 
 
template<typename, typename...>
class extended_meta_factory;
 
 
template<typename Type>
class meta_factory {
    template<typename Node>
    bool duplicate(const Node *candidate, const Node *node) ENTT_NOEXCEPT {
        return node && (node == candidate || duplicate(candidate, node->next));
    }
 
    template<typename Node>
    bool duplicate(const ENTT_ID_TYPE identifier, const Node *node) ENTT_NOEXCEPT {
        return node && (node->identifier == identifier || duplicate(identifier, node->next));
    }
 
    auto record(const ENTT_ID_TYPE identifier) ENTT_NOEXCEPT {
        auto * const node = internal::meta_info<Type>::resolve();
 
        ENTT_ASSERT(!duplicate(identifier, *internal::meta_info<>::global));
        ENTT_ASSERT(!duplicate(node, *internal::meta_info<>::global));
        node->identifier = identifier;
        node->next = *internal::meta_info<>::global;
        *internal::meta_info<>::global = node;
 
        return extended_meta_factory<Type>{&node->prop};
    }
 
public:
    auto type(const ENTT_ID_TYPE identifier) ENTT_NOEXCEPT {
        static_assert(!is_named_type_v<Type>);
        return record(identifier);
    }
 
    auto type() ENTT_NOEXCEPT {
        static_assert(is_named_type_v<Type>);
        return record(named_type_traits_t<Type>::value);
    }
 
    template<typename Base>
    auto base() ENTT_NOEXCEPT {
        static_assert(std::is_base_of_v<Base, Type>);
        auto * const type = internal::meta_info<Type>::resolve();
 
        static internal::meta_base_node node{
            type,
            nullptr,
            &internal::meta_info<Base>::resolve,
            [](void *instance) ENTT_NOEXCEPT -> void * {
                return static_cast<Base *>(static_cast<Type *>(instance));
            }
        };
 
        ENTT_ASSERT(!duplicate(&node, type->base));
        node.next = type->base;
        type->base = &node;
 
        return meta_factory<Type>{};
    }
 
    template<typename To>
    auto conv() ENTT_NOEXCEPT {
        static_assert(std::is_convertible_v<Type, To>);
        auto * const type = internal::meta_info<Type>::resolve();
 
        static internal::meta_conv_node node{
            type,
            nullptr,
            &internal::meta_info<To>::resolve,
            [](const void *instance) -> meta_any {
                return static_cast<To>(*static_cast<const Type *>(instance));
            }
        };
 
        ENTT_ASSERT(!duplicate(&node, type->conv));
        node.next = type->conv;
        type->conv = &node;
 
        return meta_factory<Type>{};
    }
 
    template<auto Candidate>
    auto conv() ENTT_NOEXCEPT {
        using conv_type = std::invoke_result_t<decltype(Candidate), Type &>;
        auto * const type = internal::meta_info<Type>::resolve();
 
        static internal::meta_conv_node node{
            type,
            nullptr,
            &internal::meta_info<conv_type>::resolve,
            [](const void *instance) -> meta_any {
                return std::invoke(Candidate, *static_cast<const Type *>(instance));
            }
        };
 
        ENTT_ASSERT(!duplicate(&node, type->conv));
        node.next = type->conv;
        type->conv = &node;
 
        return meta_factory<Type>{};
    }
 
    template<auto Func, typename Policy = as_is_t>
    auto ctor() ENTT_NOEXCEPT {
        using helper_type = internal::meta_function_helper_t<decltype(Func)>;
        static_assert(std::is_same_v<typename helper_type::return_type, Type>);
        auto * const type = internal::meta_info<Type>::resolve();
 
        static internal::meta_ctor_node node{
            type,
            nullptr,
            nullptr,
            helper_type::index_sequence.size(),
            &helper_type::arg,
            [](meta_any * const any) {
                return internal::invoke<Type, Func, Policy>({}, any, helper_type::index_sequence);
            }
        };
 
        ENTT_ASSERT(!duplicate(&node, type->ctor));
        node.next = type->ctor;
        type->ctor = &node;
 
        return extended_meta_factory<Type, std::integral_constant<decltype(Func), Func>>{&node.prop};
    }
 
    template<typename... Args>
    auto ctor() ENTT_NOEXCEPT {
        using helper_type = internal::meta_function_helper_t<Type(*)(Args...)>;
        auto * const type = internal::meta_info<Type>::resolve();
 
        static internal::meta_ctor_node node{
            type,
            nullptr,
            nullptr,
            helper_type::index_sequence.size(),
            &helper_type::arg,
            [](meta_any * const any) {
                return internal::construct<Type, std::remove_cv_t<std::remove_reference_t<Args>>...>(any, helper_type::index_sequence);
            }
        };
 
        ENTT_ASSERT(!duplicate(&node, type->ctor));
        node.next = type->ctor;
        type->ctor = &node;
 
        return extended_meta_factory<Type, Type(Args...)>{&node.prop};
    }
 
    template<auto Func>
    auto dtor() ENTT_NOEXCEPT {
        static_assert(std::is_invocable_v<decltype(Func), Type &>);
        auto * const type = internal::meta_info<Type>::resolve();
 
        static internal::meta_dtor_node node{
            type,
            [](meta_handle handle) {
                const auto valid = (handle.type() == internal::meta_info<Type>::resolve());
 
                if(valid) {
                    std::invoke(Func, *meta_any{handle}.try_cast<Type>());
                }
 
                return valid;
            }
        };
 
        ENTT_ASSERT(!type->dtor);
        type->dtor = &node;
 
        return meta_factory<Type>{};
    }
 
    template<auto Data, typename Policy = as_is_t>
    auto data(const ENTT_ID_TYPE identifier) ENTT_NOEXCEPT {
        auto * const type = internal::meta_info<Type>::resolve();
        internal::meta_data_node *curr = nullptr;
 
        if constexpr(std::is_same_v<Type, decltype(Data)>) {
            static_assert(std::is_same_v<Policy, as_is_t>);
 
            static internal::meta_data_node node{
                {},
                type,
                nullptr,
                nullptr,
                true,
                true,
                &internal::meta_info<Type>::resolve,
                [](meta_handle, meta_any, meta_any) { return false; },
                [](meta_handle, meta_any) -> meta_any { return Data; }
            };
 
            curr = &node;
        } else if constexpr(std::is_member_object_pointer_v<decltype(Data)>) {
            using data_type = std::remove_reference_t<decltype(std::declval<Type>().*Data)>;
 
            static internal::meta_data_node node{
                {},
                type,
                nullptr,
                nullptr,
                std::is_const_v<data_type>,
                !std::is_member_object_pointer_v<decltype(Data)>,
                &internal::meta_info<data_type>::resolve,
                &internal::setter<std::is_const_v<data_type>, Type, Data>,
                &internal::getter<Type, Data, Policy>
            };
 
            curr = &node;
        } else {
            static_assert(std::is_pointer_v<std::decay_t<decltype(Data)>>);
            using data_type = std::remove_pointer_t<std::decay_t<decltype(Data)>>;
 
            static internal::meta_data_node node{
                {},
                type,
                nullptr,
                nullptr,
                std::is_const_v<data_type>,
                !std::is_member_object_pointer_v<decltype(Data)>,
                &internal::meta_info<data_type>::resolve,
                &internal::setter<std::is_const_v<data_type>, Type, Data>,
                &internal::getter<Type, Data, Policy>
            };
 
            curr = &node;
        }
 
        ENTT_ASSERT(!duplicate(identifier, type->data));
        ENTT_ASSERT(!duplicate(curr, type->data));
        curr->identifier = identifier;
        curr->next = type->data;
        type->data = curr;
 
        return extended_meta_factory<Type, std::integral_constant<decltype(Data), Data>>{&curr->prop};
    }
 
    template<auto Setter, auto Getter, typename Policy = as_is_t>
    auto data(const ENTT_ID_TYPE identifier) ENTT_NOEXCEPT {
        using underlying_type = std::invoke_result_t<decltype(Getter), Type &>;
        static_assert(std::is_invocable_v<decltype(Setter), Type &, underlying_type>);
        auto * const type = internal::meta_info<Type>::resolve();
 
        static internal::meta_data_node node{
            {},
            type,
            nullptr,
            nullptr,
            false,
            false,
            &internal::meta_info<underlying_type>::resolve,
            &internal::setter<false, Type, Setter>,
            &internal::getter<Type, Getter, Policy>
        };
 
        ENTT_ASSERT(!duplicate(identifier, type->data));
        ENTT_ASSERT(!duplicate(&node, type->data));
        node.identifier = identifier;
        node.next = type->data;
        type->data = &node;
 
        return extended_meta_factory<Type, std::integral_constant<decltype(Setter), Setter>, std::integral_constant<decltype(Getter), Getter>>{&node.prop};
    }
 
    template<auto Candidate, typename Policy = as_is_t>
    auto func(const ENTT_ID_TYPE identifier) ENTT_NOEXCEPT {
        using helper_type = internal::meta_function_helper_t<decltype(Candidate)>;
        auto * const type = internal::meta_info<Type>::resolve();
 
        static internal::meta_func_node node{
            {},
            type,
            nullptr,
            nullptr,
            helper_type::index_sequence.size(),
            helper_type::is_const,
            !std::is_member_function_pointer_v<decltype(Candidate)>,
            &internal::meta_info<std::conditional_t<std::is_same_v<Policy, as_void_t>, void, typename helper_type::return_type>>::resolve,
            &helper_type::arg,
            [](meta_handle handle, meta_any *any) {
                return internal::invoke<Type, Candidate, Policy>(handle, any, helper_type::index_sequence);
            }
        };
 
        ENTT_ASSERT(!duplicate(identifier, type->func));
        ENTT_ASSERT(!duplicate(&node, type->func));
        node.identifier = identifier;
        node.next = type->func;
        type->func = &node;
 
        return extended_meta_factory<Type, std::integral_constant<decltype(Candidate), Candidate>>{&node.prop};
    }
 
    void reset() ENTT_NOEXCEPT {
        internal::meta_info<Type>::reset();
    }
};
 
 
template<typename Type, typename... Spec>
class extended_meta_factory: public meta_factory<Type> {
    bool duplicate(const meta_any &key, const internal::meta_prop_node *node) ENTT_NOEXCEPT {
        return node && (node->key() == key || duplicate(key, node->next));
    }
 
    template<std::size_t Step = 0, std::size_t... Index, typename... Property, typename... Other>
    void unpack(std::index_sequence<Index...>, std::tuple<Property...> property, Other &&... other) {
        unroll<Step>(choice<3>, std::move(std::get<Index>(property))..., std::forward<Other>(other)...);
    }
 
    template<std::size_t Step = 0, typename... Property, typename... Other>
    void unroll(choice_t<3>, std::tuple<Property...> property, Other &&... other) {
        unpack<Step>(std::index_sequence_for<Property...>{}, std::move(property), std::forward<Other>(other)...);
    }
 
    template<std::size_t Step = 0, typename... Property, typename... Other>
    void unroll(choice_t<2>, std::pair<Property...> property, Other &&... other) {
        assign<Step>(std::move(property.first), std::move(property.second));
        unroll<Step+1>(choice<3>, std::forward<Other>(other)...);
    }
 
    template<std::size_t Step = 0, typename Property, typename... Other>
    std::enable_if_t<!std::is_invocable_v<Property>>
    unroll(choice_t<1>, Property &&property, Other &&... other) {
        assign<Step>(std::forward<Property>(property));
        unroll<Step+1>(choice<3>, std::forward<Other>(other)...);
    }
 
    template<std::size_t Step = 0, typename Func, typename... Other>
    void unroll(choice_t<0>, Func &&invocable, Other &&... other) {
        unroll<Step>(choice<3>, std::forward<Func>(invocable)(), std::forward<Other>(other)...);
    }
 
    template<std::size_t>
    void unroll(choice_t<0>) {}
 
    template<std::size_t = 0, typename Key, typename... Value>
    void assign(Key &&key, Value &&... value) {
        static auto property{std::make_tuple(std::forward<Key>(key), std::forward<Value>(value)...)};
 
        static internal::meta_prop_node node{
            nullptr,
            []() -> meta_any {
                return std::get<0>(property);
            },
            []() -> meta_any {
                if constexpr(sizeof...(Value) == 0) {
                    return {};
                } else {
                    return std::get<1>(property);
                }
            }
        };
 
        ENTT_ASSERT(!duplicate(node.key(), *curr));
        node.next = *curr;
        *curr = &node;
    }
 
public:
    extended_meta_factory(entt::internal::meta_prop_node **target)
        : curr{target}
    {}
 
    template<typename PropertyOrKey, typename... Value>
    auto prop(PropertyOrKey &&property_or_key, Value &&... value) && {
        if constexpr(sizeof...(Value) == 0) {
            unroll(choice<3>, std::forward<PropertyOrKey>(property_or_key));
        } else {
            assign(std::forward<PropertyOrKey>(property_or_key), std::forward<Value>(value)...);
        }
 
        return extended_meta_factory<Type, Spec..., PropertyOrKey, Value...>{curr};
    }
 
    template <typename... Property>
    auto props(Property... property) && {
        unroll(choice<3>, std::forward<Property>(property)...);
        return extended_meta_factory<Type, Spec..., Property...>{curr};
    }
 
private:
    entt::internal::meta_prop_node **curr{nullptr};
};
 
 
template<typename Type>
inline meta_factory<Type> meta() ENTT_NOEXCEPT {
    return meta_factory<Type>{};
}
 
 
template<typename Type>
inline meta_type resolve() ENTT_NOEXCEPT {
    return internal::meta_info<Type>::resolve();
}
 
 
inline meta_type resolve(const ENTT_ID_TYPE identifier) ENTT_NOEXCEPT {
    return internal::find_if([identifier](auto *node) {
        return node->identifier == identifier;
    }, *internal::meta_info<>::global);
}
 
 
template<typename Op>
inline std::enable_if_t<std::is_invocable_v<Op, meta_type>, void>
resolve(Op op) ENTT_NOEXCEPT {
    internal::iterate<meta_type>(std::move(op), *internal::meta_info<>::global);
}
 
 
}
 
 
#endif // ENTT_META_FACTORY_HPP
 
// #include "meta/meta.hpp"
 
// #include "meta/policy.hpp"
 
// #include "process/process.hpp"
#ifndef ENTT_PROCESS_PROCESS_HPP
#define ENTT_PROCESS_PROCESS_HPP
 
 
#include <utility>
#include <type_traits>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
template<typename Derived, typename Delta>
class process {
    enum class state: unsigned int {
        UNINITIALIZED = 0,
        RUNNING,
        PAUSED,
        SUCCEEDED,
        FAILED,
        ABORTED,
        FINISHED
    };
 
    template<state value>
    using state_value_t = std::integral_constant<state, value>;
 
    template<typename Target = Derived>
    auto tick(int, state_value_t<state::UNINITIALIZED>)
    -> decltype(std::declval<Target>().init()) {
        static_cast<Target *>(this)->init();
    }
 
    template<typename Target = Derived>
    auto tick(int, state_value_t<state::RUNNING>, Delta delta, void *data)
    -> decltype(std::declval<Target>().update(delta, data)) {
        static_cast<Target *>(this)->update(delta, data);
    }
 
    template<typename Target = Derived>
    auto tick(int, state_value_t<state::SUCCEEDED>)
    -> decltype(std::declval<Target>().succeeded()) {
        static_cast<Target *>(this)->succeeded();
    }
 
    template<typename Target = Derived>
    auto tick(int, state_value_t<state::FAILED>)
    -> decltype(std::declval<Target>().failed()) {
        static_cast<Target *>(this)->failed();
    }
 
    template<typename Target = Derived>
    auto tick(int, state_value_t<state::ABORTED>)
    -> decltype(std::declval<Target>().aborted()) {
        static_cast<Target *>(this)->aborted();
    }
 
    template<state value, typename... Args>
    void tick(char, state_value_t<value>, Args &&...) const ENTT_NOEXCEPT {}
 
protected:
    void succeed() ENTT_NOEXCEPT {
        if(alive()) {
            current = state::SUCCEEDED;
        }
    }
 
    void fail() ENTT_NOEXCEPT {
        if(alive()) {
            current = state::FAILED;
        }
    }
 
    void pause() ENTT_NOEXCEPT {
        if(current == state::RUNNING) {
            current = state::PAUSED;
        }
    }
 
    void unpause() ENTT_NOEXCEPT {
        if(current  == state::PAUSED) {
            current  = state::RUNNING;
        }
    }
 
public:
    using delta_type = Delta;
 
    virtual ~process() ENTT_NOEXCEPT {
        static_assert(std::is_base_of_v<process, Derived>);
    }
 
    void abort(const bool immediately = false) ENTT_NOEXCEPT {
        if(alive()) {
            current = state::ABORTED;
 
            if(immediately) {
                tick({});
            }
        }
    }
 
    bool alive() const ENTT_NOEXCEPT {
        return current == state::RUNNING || current == state::PAUSED;
    }
 
    bool dead() const ENTT_NOEXCEPT {
        return current == state::FINISHED;
    }
 
    bool paused() const ENTT_NOEXCEPT {
        return current == state::PAUSED;
    }
 
    bool rejected() const ENTT_NOEXCEPT {
        return stopped;
    }
 
    void tick(const Delta delta, void *data = nullptr) {
        switch (current) {
        case state::UNINITIALIZED:
            tick(0, state_value_t<state::UNINITIALIZED>{});
            current = state::RUNNING;
            break;
        case state::RUNNING:
            tick(0, state_value_t<state::RUNNING>{}, delta, data);
            break;
        default:
            // suppress warnings
            break;
        }
 
        // if it's dead, it must be notified and removed immediately
        switch(current) {
        case state::SUCCEEDED:
            tick(0, state_value_t<state::SUCCEEDED>{});
            current = state::FINISHED;
            break;
        case state::FAILED:
            tick(0, state_value_t<state::FAILED>{});
            current = state::FINISHED;
            stopped = true;
            break;
        case state::ABORTED:
            tick(0, state_value_t<state::ABORTED>{});
            current = state::FINISHED;
            stopped = true;
            break;
        default:
            // suppress warnings
            break;
        }
    }
 
private:
    state current{state::UNINITIALIZED};
    bool stopped{false};
};
 
 
template<typename Func, typename Delta>
struct process_adaptor: process<process_adaptor<Func, Delta>, Delta>, private Func {
    template<typename... Args>
    process_adaptor(Args &&... args)
        : Func{std::forward<Args>(args)...}
    {}
 
    void update(const Delta delta, void *data) {
        Func::operator()(delta, data, [this]() { this->succeed(); }, [this]() { this->fail(); });
    }
};
 
 
}
 
 
#endif // ENTT_PROCESS_PROCESS_HPP
 
// #include "process/scheduler.hpp"
#ifndef ENTT_PROCESS_SCHEDULER_HPP
#define ENTT_PROCESS_SCHEDULER_HPP
 
 
#include <vector>
#include <memory>
#include <utility>
#include <algorithm>
#include <type_traits>
// #include "../config/config.h"
 
// #include "process.hpp"
 
 
 
namespace entt {
 
 
template<typename Delta>
class scheduler {
    struct process_handler {
        using instance_type = std::unique_ptr<void, void(*)(void *)>;
        using update_fn_type = bool(process_handler &, Delta, void *);
        using abort_fn_type = void(process_handler &, bool);
        using next_type = std::unique_ptr<process_handler>;
 
        instance_type instance;
        update_fn_type *update;
        abort_fn_type *abort;
        next_type next;
    };
 
    struct continuation {
        continuation(process_handler *ref)
            : handler{ref}
        {
            ENTT_ASSERT(handler);
        }
 
        template<typename Proc, typename... Args>
        continuation then(Args &&... args) {
            static_assert(std::is_base_of_v<process<Proc, Delta>, Proc>);
            auto proc = typename process_handler::instance_type{new Proc{std::forward<Args>(args)...}, &scheduler::deleter<Proc>};
            handler->next.reset(new process_handler{std::move(proc), &scheduler::update<Proc>, &scheduler::abort<Proc>, nullptr});
            handler = handler->next.get();
            return *this;
        }
 
        template<typename Func>
        continuation then(Func &&func) {
            return then<process_adaptor<std::decay_t<Func>, Delta>>(std::forward<Func>(func));
        }
 
    private:
        process_handler *handler;
    };
 
    template<typename Proc>
    static bool update(process_handler &handler, const Delta delta, void *data) {
        auto *process = static_cast<Proc *>(handler.instance.get());
        process->tick(delta, data);
 
        auto dead = process->dead();
 
        if(dead) {
            if(handler.next && !process->rejected()) {
                handler = std::move(*handler.next);
                // forces the process to exit the uninitialized state
                dead = handler.update(handler, {}, nullptr);
            } else {
                handler.instance.reset();
            }
        }
 
        return dead;
    }
 
    template<typename Proc>
    static void abort(process_handler &handler, const bool immediately) {
        static_cast<Proc *>(handler.instance.get())->abort(immediately);
    }
 
    template<typename Proc>
    static void deleter(void *proc) {
        delete static_cast<Proc *>(proc);
    }
 
public:
    using size_type = std::size_t;
 
    scheduler() ENTT_NOEXCEPT = default;
 
    scheduler(scheduler &&) = default;
 
    scheduler & operator=(scheduler &&) = default;
 
    size_type size() const ENTT_NOEXCEPT {
        return handlers.size();
    }
 
    bool empty() const ENTT_NOEXCEPT {
        return handlers.empty();
    }
 
    void clear() {
        handlers.clear();
    }
 
    template<typename Proc, typename... Args>
    auto attach(Args &&... args) {
        static_assert(std::is_base_of_v<process<Proc, Delta>, Proc>);
        auto proc = typename process_handler::instance_type{new Proc{std::forward<Args>(args)...}, &scheduler::deleter<Proc>};
        process_handler handler{std::move(proc), &scheduler::update<Proc>, &scheduler::abort<Proc>, nullptr};
        // forces the process to exit the uninitialized state
        handler.update(handler, {}, nullptr);
        return continuation{&handlers.emplace_back(std::move(handler))};
    }
 
    template<typename Func>
    auto attach(Func &&func) {
        using Proc = process_adaptor<std::decay_t<Func>, Delta>;
        return attach<Proc>(std::forward<Func>(func));
    }
 
    void update(const Delta delta, void *data = nullptr) {
        bool clean = false;
 
        for(auto pos = handlers.size(); pos; --pos) {
            auto &handler = handlers[pos-1];
            const bool dead = handler.update(handler, delta, data);
            clean = clean || dead;
        }
 
        if(clean) {
            handlers.erase(std::remove_if(handlers.begin(), handlers.end(), [](auto &handler) {
                return !handler.instance;
            }), handlers.end());
        }
    }
 
    void abort(const bool immediately = false) {
        decltype(handlers) exec;
        exec.swap(handlers);
 
        std::for_each(exec.begin(), exec.end(), [immediately](auto &handler) {
            handler.abort(handler, immediately);
        });
 
        std::move(handlers.begin(), handlers.end(), std::back_inserter(exec));
        handlers.swap(exec);
    }
 
private:
    std::vector<process_handler> handlers{};
};
 
 
}
 
 
#endif // ENTT_PROCESS_SCHEDULER_HPP
 
// #include "resource/cache.hpp"
#ifndef ENTT_RESOURCE_CACHE_HPP
#define ENTT_RESOURCE_CACHE_HPP
 
 
#include <memory>
#include <utility>
#include <type_traits>
#include <unordered_map>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
// #include "handle.hpp"
#ifndef ENTT_RESOURCE_HANDLE_HPP
#define ENTT_RESOURCE_HANDLE_HPP
 
 
#include <memory>
#include <utility>
// #include "../config/config.h"
 
// #include "fwd.hpp"
#ifndef ENTT_RESOURCE_FWD_HPP
#define ENTT_RESOURCE_FWD_HPP
 
 
namespace entt {
 
 
template<typename>
struct cache;
 
template<typename>
class handle;
 
template<typename, typename>
class loader;
 
 
}
 
 
#endif // ENTT_RESOURCE_FWD_HPP
 
 
 
namespace entt {
 
 
template<typename Resource>
class handle {
    friend struct cache<Resource>;
 
    handle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
        : resource{std::move(res)}
    {}
 
public:
    handle() ENTT_NOEXCEPT = default;
 
    const Resource & get() const ENTT_NOEXCEPT {
        ENTT_ASSERT(static_cast<bool>(resource));
        return *resource;
    }
 
    Resource & get() ENTT_NOEXCEPT {
        return const_cast<Resource &>(std::as_const(*this).get());
    }
 
    operator const Resource & () const ENTT_NOEXCEPT { return get(); }
 
    operator Resource & () ENTT_NOEXCEPT { return get(); }
 
    const Resource & operator *() const ENTT_NOEXCEPT { return get(); }
 
    Resource & operator *() ENTT_NOEXCEPT { return get(); }
 
    const Resource * operator->() const ENTT_NOEXCEPT {
        ENTT_ASSERT(static_cast<bool>(resource));
        return resource.get();
    }
 
    Resource * operator->() ENTT_NOEXCEPT {
        return const_cast<Resource *>(std::as_const(*this).operator->());
    }
 
    explicit operator bool() const { return static_cast<bool>(resource); }
 
private:
    std::shared_ptr<Resource> resource;
};
 
 
}
 
 
#endif // ENTT_RESOURCE_HANDLE_HPP
 
// #include "loader.hpp"
#ifndef ENTT_RESOURCE_LOADER_HPP
#define ENTT_RESOURCE_LOADER_HPP
 
 
#include <memory>
// #include "fwd.hpp"
 
 
 
namespace entt {
 
 
template<typename Loader, typename Resource>
class loader {
    friend struct cache<Resource>;
 
    template<typename... Args>
    std::shared_ptr<Resource> get(Args &&... args) const {
        return static_cast<const Loader *>(this)->load(std::forward<Args>(args)...);
    }
};
 
 
}
 
 
#endif // ENTT_RESOURCE_LOADER_HPP
 
// #include "fwd.hpp"
 
 
 
namespace entt {
 
 
template<typename Resource>
struct cache {
    using size_type = std::size_t;
    using resource_type = Resource;
    using id_type = ENTT_ID_TYPE;
 
    cache() = default;
 
    cache(cache &&) = default;
 
    cache & operator=(cache &&) = default;
 
    size_type size() const ENTT_NOEXCEPT {
        return resources.size();
    }
 
    bool empty() const ENTT_NOEXCEPT {
        return resources.empty();
    }
 
    void clear() ENTT_NOEXCEPT {
        resources.clear();
    }
 
    template<typename Loader, typename... Args>
    entt::handle<Resource> load(const id_type id, Args &&... args) {
        static_assert(std::is_base_of_v<loader<Loader, Resource>, Loader>);
        entt::handle<Resource> resource{};
 
        if(auto it = resources.find(id); it == resources.cend()) {
            if(auto instance = Loader{}.get(std::forward<Args>(args)...); instance) {
                resources[id] = instance;
                resource = std::move(instance);
            }
        } else {
            resource = it->second;
        }
 
        return resource;
    }
 
    template<typename Loader, typename... Args>
    entt::handle<Resource> reload(const id_type id, Args &&... args) {
        return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
    }
 
    template<typename Loader, typename... Args>
    entt::handle<Resource> temp(Args &&... args) const {
        return { Loader{}.get(std::forward<Args>(args)...) };
    }
 
    entt::handle<Resource> handle(const id_type id) const {
        auto it = resources.find(id);
        return { it == resources.end() ? nullptr : it->second };
    }
 
    bool contains(const id_type id) const ENTT_NOEXCEPT {
        return (resources.find(id) != resources.cend());
    }
 
    void discard(const id_type id) ENTT_NOEXCEPT {
        if(auto it = resources.find(id); it != resources.end()) {
            resources.erase(it);
        }
    }
 
    template <typename Func>
    void each(Func func) const {
        auto begin = resources.begin();
        auto end = resources.end();
 
        while(begin != end) {
            auto curr = begin++;
 
            if constexpr(std::is_invocable_v<Func, id_type>) {
                func(curr->first);
            } else if constexpr(std::is_invocable_v<Func, entt::handle<Resource>>) {
                func(entt::handle{ curr->second });
            } else {
                func(curr->first, entt::handle{ curr->second });
            }
        }
    }
 
private:
    std::unordered_map<id_type, std::shared_ptr<Resource>> resources;
};
 
 
}
 
 
#endif // ENTT_RESOURCE_CACHE_HPP
 
// #include "resource/handle.hpp"
 
// #include "resource/loader.hpp"
 
// #include "signal/delegate.hpp"
#ifndef ENTT_SIGNAL_DELEGATE_HPP
#define ENTT_SIGNAL_DELEGATE_HPP
 
 
#include <tuple>
#include <cstring>
#include <utility>
#include <algorithm>
#include <functional>
#include <type_traits>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
namespace internal {
 
 
template<typename Ret, typename... Args>
auto to_function_pointer(Ret(*)(Args...)) -> Ret(*)(Args...);
 
 
template<typename Ret, typename... Args, typename Type, typename Payload, typename = std::enable_if_t<std::is_convertible_v<const Payload *, const Type *>>>
auto to_function_pointer(Ret(*)(Type &, Args...), const Payload *) -> Ret(*)(Args...);
 
 
template<typename Ret, typename... Args, typename Type, typename Payload, typename = std::enable_if_t<std::is_convertible_v<const Payload *, const Type *>>>
auto to_function_pointer(Ret(*)(Type *, Args...), const Payload *) -> Ret(*)(Args...);
 
 
template<typename Class, typename Ret, typename... Args>
auto to_function_pointer(Ret(Class:: *)(Args...), const Class *) -> Ret(*)(Args...);
 
 
template<typename Class, typename Ret, typename... Args>
auto to_function_pointer(Ret(Class:: *)(Args...) const, const Class *) -> Ret(*)(Args...);
 
 
template<typename Class, typename Type>
auto to_function_pointer(Type Class:: *, const Class *) -> Type(*)();
 
 
template<typename... Type>
using to_function_pointer_t = decltype(internal::to_function_pointer(std::declval<Type>()...));
 
 
template<typename Ret, typename... Args>
constexpr auto index_sequence_for(Ret(*)(Args...)) {
    return std::index_sequence_for<Args...>{};
}
 
 
}
 
 
template<auto>
struct connect_arg_t {};
 
 
template<auto Func>
constexpr connect_arg_t<Func> connect_arg{};
 
 
template<typename>
class delegate;
 
 
template<typename Ret, typename... Args>
class delegate<Ret(Args...)> {
    using proto_fn_type = Ret(const void *, std::tuple<Args &&...>);
 
    template<auto Function, std::size_t... Index>
    void connect(std::index_sequence<Index...>) ENTT_NOEXCEPT {
        static_assert(std::is_invocable_r_v<Ret, decltype(Function), std::tuple_element_t<Index, std::tuple<Args...>>...>);
        data = nullptr;
 
        fn = [](const void *, std::tuple<Args &&...> args) -> Ret {
            // Ret(...) makes void(...) eat the return values to avoid errors
            return Ret(std::invoke(Function, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
        };
    }
 
    template<auto Candidate, typename Type, std::size_t... Index>
    void connect(Type &value_or_instance, std::index_sequence<Index...>) ENTT_NOEXCEPT {
        static_assert(std::is_invocable_r_v<Ret, decltype(Candidate), Type &, std::tuple_element_t<Index, std::tuple<Args...>>...>);
        data = &value_or_instance;
 
        fn = [](const void *payload, std::tuple<Args &&...> args) -> Ret {
            Type *curr = static_cast<Type *>(const_cast<std::conditional_t<std::is_const_v<Type>, const void *, void *>>(payload));
            // Ret(...) makes void(...) eat the return values to avoid errors
            return Ret(std::invoke(Candidate, *curr, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
        };
    }
 
    template<auto Candidate, typename Type, std::size_t... Index>
    void connect(Type *value_or_instance, std::index_sequence<Index...>) ENTT_NOEXCEPT {
        static_assert(std::is_invocable_r_v<Ret, decltype(Candidate), Type *, std::tuple_element_t<Index, std::tuple<Args...>>...>);
        data = value_or_instance;
 
        fn = [](const void *payload, std::tuple<Args &&...> args) -> Ret {
            Type *curr = static_cast<Type *>(const_cast<std::conditional_t<std::is_const_v<Type>, const void *, void *>>(payload));
            // Ret(...) makes void(...) eat the return values to avoid errors
            return Ret(std::invoke(Candidate, curr, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
        };
    }
 
public:
    using function_type = Ret(Args...);
 
    delegate() ENTT_NOEXCEPT
        : fn{nullptr}, data{nullptr}
    {}
 
    template<auto Function>
    delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
        : delegate{}
    {
        connect<Function>();
    }
 
    template<auto Candidate, typename Type>
    delegate(connect_arg_t<Candidate>, Type &value_or_instance) ENTT_NOEXCEPT
        : delegate{}
    {
        connect<Candidate>(value_or_instance);
    }
 
    template<auto Candidate, typename Type>
    delegate(connect_arg_t<Candidate>, Type *value_or_instance) ENTT_NOEXCEPT
        : delegate{}
    {
        connect<Candidate>(value_or_instance);
    }
 
    template<auto Function>
    void connect() ENTT_NOEXCEPT {
        connect<Function>(internal::index_sequence_for(internal::to_function_pointer_t<decltype(Function)>{}));
    }
 
    template<auto Candidate, typename Type>
    void connect(Type &value_or_instance) ENTT_NOEXCEPT {
        connect<Candidate>(value_or_instance, internal::index_sequence_for(internal::to_function_pointer_t<decltype(Candidate), Type *>{}));
    }
 
    template<auto Candidate, typename Type>
    void connect(Type *value_or_instance) ENTT_NOEXCEPT {
        connect<Candidate>(value_or_instance, internal::index_sequence_for(internal::to_function_pointer_t<decltype(Candidate), Type *>{}));
    }
 
    void reset() ENTT_NOEXCEPT {
        fn = nullptr;
        data = nullptr;
    }
 
    const void * instance() const ENTT_NOEXCEPT {
        return data;
    }
 
    Ret operator()(Args... args) const {
        ENTT_ASSERT(fn);
        return fn(data, std::forward_as_tuple(std::forward<Args>(args)...));
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        // no need to test also data
        return fn;
    }
 
    bool operator==(const delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
        return fn == other.fn && data == other.data;
    }
 
private:
    proto_fn_type *fn;
    const void *data;
};
 
 
template<typename Ret, typename... Args>
bool operator!=(const delegate<Ret(Args...)> &lhs, const delegate<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
template<auto Function>
delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
-> delegate<std::remove_pointer_t<internal::to_function_pointer_t<decltype(Function)>>>;
 
 
template<auto Candidate, typename Type>
delegate(connect_arg_t<Candidate>, Type &) ENTT_NOEXCEPT
-> delegate<std::remove_pointer_t<internal::to_function_pointer_t<decltype(Candidate), Type *>>>;
 
 
template<auto Candidate, typename Type>
delegate(connect_arg_t<Candidate>, Type *) ENTT_NOEXCEPT
-> delegate<std::remove_pointer_t<internal::to_function_pointer_t<decltype(Candidate), Type *>>>;
 
 
}
 
 
#endif // ENTT_SIGNAL_DELEGATE_HPP
 
// #include "signal/dispatcher.hpp"
#ifndef ENTT_SIGNAL_DISPATCHER_HPP
#define ENTT_SIGNAL_DISPATCHER_HPP
 
 
#include <vector>
#include <memory>
#include <cstddef>
#include <utility>
#include <algorithm>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/family.hpp"
#ifndef ENTT_CORE_FAMILY_HPP
#define ENTT_CORE_FAMILY_HPP
 
 
#include <type_traits>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
template<typename...>
class family {
    inline static ENTT_MAYBE_ATOMIC(ENTT_ID_TYPE) identifier{};
 
public:
    using family_type = ENTT_ID_TYPE;
 
    template<typename... Type>
    // at the time I'm writing, clang crashes during compilation if auto is used instead of family_type
    inline static const family_type type = identifier++;
};
 
 
}
 
 
#endif // ENTT_CORE_FAMILY_HPP
 
// #include "../core/type_traits.hpp"
#ifndef ENTT_CORE_TYPE_TRAITS_HPP
#define ENTT_CORE_TYPE_TRAITS_HPP
 
 
#include <cstddef>
#include <type_traits>
// #include "../config/config.h"
 
// #include "../core/hashed_string.hpp"
#ifndef ENTT_CORE_HASHED_STRING_HPP
#define ENTT_CORE_HASHED_STRING_HPP
 
 
#include <cstddef>
// #include "../config/config.h"
#ifndef ENTT_CONFIG_CONFIG_H
#define ENTT_CONFIG_CONFIG_H
 
 
#ifndef ENTT_NOEXCEPT
#define ENTT_NOEXCEPT noexcept
#endif // ENTT_NOEXCEPT
 
 
#ifndef ENTT_HS_SUFFIX
#define ENTT_HS_SUFFIX _hs
#endif // ENTT_HS_SUFFIX
 
 
#ifndef ENTT_HWS_SUFFIX
#define ENTT_HWS_SUFFIX _hws
#endif // ENTT_HWS_SUFFIX
 
 
#ifndef ENTT_NO_ATOMIC
#include <atomic>
#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
#else // ENTT_NO_ATOMIC
#define ENTT_MAYBE_ATOMIC(Type) Type
#endif // ENTT_NO_ATOMIC
 
 
#ifndef ENTT_DISABLE_ETO
#include <type_traits>
#define ENTT_ENABLE_ETO(Type) std::is_empty_v<Type>
#else // ENTT_DISABLE_ETO
// sfinae-friendly definition
#define ENTT_ENABLE_ETO(Type) (false && std::is_empty_v<Type>)
#endif // ENTT_DISABLE_ETO
 
 
#ifndef ENTT_ID_TYPE
#include <cstdint>
#define ENTT_ID_TYPE std::uint32_t
#endif // ENTT_ID_TYPE
 
 
#ifndef ENTT_PAGE_SIZE
#define ENTT_PAGE_SIZE 32768
#endif // ENTT_PAGE_SIZE
 
 
#ifndef ENTT_DISABLE_ASSERT
#include <cassert>
#define ENTT_ASSERT(condition) assert(condition)
#else // ENTT_DISABLE_ASSERT
#define ENTT_ASSERT(...) ((void)0)
#endif // ENTT_DISABLE_ASSERT
 
 
#endif // ENTT_CONFIG_CONFIG_H
 
 
 
namespace entt {
 
 
namespace internal {
 
 
template<typename>
struct fnv1a_traits;
 
 
template<>
struct fnv1a_traits<std::uint32_t> {
    static constexpr std::uint32_t offset = 2166136261;
    static constexpr std::uint32_t prime = 16777619;
};
 
 
template<>
struct fnv1a_traits<std::uint64_t> {
    static constexpr std::uint64_t offset = 14695981039346656037ull;
    static constexpr std::uint64_t prime = 1099511628211ull;
};
 
 
}
 
 
template<typename Char>
class basic_hashed_string {
    using traits_type = internal::fnv1a_traits<ENTT_ID_TYPE>;
 
    struct const_wrapper {
        // non-explicit constructor on purpose
        constexpr const_wrapper(const Char *curr) ENTT_NOEXCEPT: str{curr} {}
        const Char *str;
    };
 
    // Fowler–Noll–Vo hash function v. 1a - the good
    static constexpr ENTT_ID_TYPE helper(ENTT_ID_TYPE partial, const Char *curr) ENTT_NOEXCEPT {
        return curr[0] == 0 ? partial : helper((partial^curr[0])*traits_type::prime, curr+1);
    }
 
public:
    using value_type = Char;
    using hash_type = ENTT_ID_TYPE;
 
    template<std::size_t N>
    static constexpr hash_type to_value(const value_type (&str)[N]) ENTT_NOEXCEPT {
        return helper(traits_type::offset, str);
    }
 
    static hash_type to_value(const_wrapper wrapper) ENTT_NOEXCEPT {
        return helper(traits_type::offset, wrapper.str);
    }
 
    static hash_type to_value(const value_type *str, std::size_t size) ENTT_NOEXCEPT {
        ENTT_ID_TYPE partial{traits_type::offset};
        while(size--) { partial = (partial^(str++)[0])*traits_type::prime; }
        return partial;
    }
 
    constexpr basic_hashed_string() ENTT_NOEXCEPT
        : str{nullptr}, hash{}
    {}
 
    template<std::size_t N>
    constexpr basic_hashed_string(const value_type (&curr)[N]) ENTT_NOEXCEPT
        : str{curr}, hash{helper(traits_type::offset, curr)}
    {}
 
    explicit constexpr basic_hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT
        : str{wrapper.str}, hash{helper(traits_type::offset, wrapper.str)}
    {}
 
    constexpr const value_type * data() const ENTT_NOEXCEPT {
        return str;
    }
 
    constexpr hash_type value() const ENTT_NOEXCEPT {
        return hash;
    }
 
    constexpr operator const value_type *() const ENTT_NOEXCEPT { return str; }
 
    constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
 
    constexpr bool operator==(const basic_hashed_string &other) const ENTT_NOEXCEPT {
        return hash == other.hash;
    }
 
private:
    const value_type *str;
    hash_type hash;
};
 
 
template<typename Char, std::size_t N>
basic_hashed_string(const Char (&str)[N]) ENTT_NOEXCEPT
-> basic_hashed_string<Char>;
 
 
template<typename Char>
constexpr bool operator!=(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
    return !(lhs == rhs);
}
 
 
using hashed_string = basic_hashed_string<char>;
 
 
using hashed_wstring = basic_hashed_string<wchar_t>;
 
 
}
 
 
constexpr entt::hashed_string operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_string{str};
}
 
 
constexpr entt::hashed_wstring operator"" ENTT_HWS_SUFFIX(const wchar_t *str, std::size_t) ENTT_NOEXCEPT {
    return entt::hashed_wstring{str};
}
 
 
#endif // ENTT_CORE_HASHED_STRING_HPP
 
 
 
namespace entt {
 
 
template<std::size_t N>
struct choice_t
        // Unfortunately, doxygen cannot parse such a construct.
        : choice_t<N-1>
{};
 
 
template<>
struct choice_t<0> {};
 
 
template<std::size_t N>
constexpr choice_t<N> choice{};
 
 
template<typename...>
struct type_list {};
 
 
template<typename>
struct type_list_size;
 
 
template<typename... Type>
struct type_list_size<type_list<Type...>>
        : std::integral_constant<std::size_t, sizeof...(Type)>
{};
 
 
template<class List>
constexpr auto type_list_size_v = type_list_size<List>::value;
 
 
template<typename...>
struct type_list_cat;
 
 
template<>
struct type_list_cat<> {
    using type = type_list<>;
};
 
 
template<typename... Type, typename... Other, typename... List>
struct type_list_cat<type_list<Type...>, type_list<Other...>, List...> {
    using type = typename type_list_cat<type_list<Type..., Other...>, List...>::type;
};
 
 
template<typename... Type>
struct type_list_cat<type_list<Type...>> {
    using type = type_list<Type...>;
};
 
 
template<typename... List>
using type_list_cat_t = typename type_list_cat<List...>::type;
 
 
template<typename>
struct type_list_unique;
 
 
template<typename Type, typename... Other>
struct type_list_unique<type_list<Type, Other...>> {
    using type = std::conditional_t<
        std::disjunction_v<std::is_same<Type, Other>...>,
        typename type_list_unique<type_list<Other...>>::type,
        type_list_cat_t<type_list<Type>, typename type_list_unique<type_list<Other...>>::type>
    >;
};
 
 
template<>
struct type_list_unique<type_list<>> {
    using type = type_list<>;
};
 
 
template<typename Type>
using type_list_unique_t = typename type_list_unique<Type>::type;
 
 
template<typename Type, typename = std::void_t<>>
struct is_equality_comparable: std::false_type {};
 
 
template<typename Type>
struct is_equality_comparable<Type, std::void_t<decltype(std::declval<Type>() == std::declval<Type>())>>: std::true_type {};
 
 
template<class Type>
constexpr auto is_equality_comparable_v = is_equality_comparable<Type>::value;
 
 
template<typename>
struct named_type_traits;
 
 
template<typename Type>
struct named_type_traits<const Type>
        : named_type_traits<Type>
{};
 
 
template<typename Type>
using named_type_traits_t = typename named_type_traits<Type>::type;
 
 
template<class Type>
constexpr auto named_type_traits_v = named_type_traits<Type>::value;
 
 
template<typename Type, typename = std::void_t<>>
struct is_named_type: std::false_type {};
 
 
template<typename Type>
struct is_named_type<Type, std::void_t<named_type_traits_t<std::decay_t<Type>>>>: std::true_type {};
 
 
template<class Type>
constexpr auto is_named_type_v = is_named_type<Type>::value;
 
 
#define ENTT_OPAQUE_TYPE(clazz, type)\
    enum class clazz: type {};\
    constexpr auto to_integer(const clazz id) ENTT_NOEXCEPT {\
        return std::underlying_type_t<clazz>(id);\
    }\
    static_assert(true)
 
 
}
 
 
#define ENTT_EXPAND(args) args
 
 
#define ENTT_NAMED_TYPE(type)\
    template<>\
    struct entt::named_type_traits<type>\
        : std::integral_constant<ENTT_ID_TYPE, entt::basic_hashed_string<std::remove_cv_t<std::remove_pointer_t<std::decay_t<decltype(#type)>>>>{#type}>\
    {\
        static_assert(std::is_same_v<std::remove_cv_t<type>, type>);\
        static_assert(std::is_object_v<type>);\
    }
 
 
#define ENTT_NAMED_STRUCT_ONLY(clazz, body)\
    struct clazz body;\
    ENTT_NAMED_TYPE(clazz)
 
 
#define ENTT_NAMED_STRUCT_WITH_NAMESPACE(ns, clazz, body)\
    namespace ns { struct clazz body; }\
    ENTT_NAMED_TYPE(ns::clazz)
 
 
#define ENTT_NAMED_STRUCT_OVERLOAD(_1, _2, _3, FUNC, ...) FUNC
 
#define ENTT_NAMED_STRUCT(...) ENTT_EXPAND(ENTT_NAMED_STRUCT_OVERLOAD(__VA_ARGS__, ENTT_NAMED_STRUCT_WITH_NAMESPACE, ENTT_NAMED_STRUCT_ONLY,)(__VA_ARGS__))
 
 
#define ENTT_NAMED_CLASS_ONLY(clazz, body)\
    class clazz body;\
    ENTT_NAMED_TYPE(clazz)
 
 
#define ENTT_NAMED_CLASS_WITH_NAMESPACE(ns, clazz, body)\
    namespace ns { class clazz body; }\
    ENTT_NAMED_TYPE(ns::clazz)
 
 
#define ENTT_NAMED_CLASS_MACRO(_1, _2, _3, FUNC, ...) FUNC
 
#define ENTT_NAMED_CLASS(...) ENTT_EXPAND(ENTT_NAMED_CLASS_MACRO(__VA_ARGS__, ENTT_NAMED_CLASS_WITH_NAMESPACE, ENTT_NAMED_CLASS_ONLY,)(__VA_ARGS__))
 
 
#endif // ENTT_CORE_TYPE_TRAITS_HPP
 
// #include "sigh.hpp"
#ifndef ENTT_SIGNAL_SIGH_HPP
#define ENTT_SIGNAL_SIGH_HPP
 
 
#include <vector>
#include <utility>
#include <iterator>
#include <algorithm>
#include <functional>
#include <type_traits>
// #include "../config/config.h"
 
// #include "delegate.hpp"
 
// #include "fwd.hpp"
#ifndef ENTT_SIGNAL_FWD_HPP
#define ENTT_SIGNAL_FWD_HPP
 
 
namespace entt {
 
 
template<typename>
class delegate;
 
template<typename>
class sink;
 
template<typename>
class sigh;
 
 
}
 
 
#endif // ENTT_SIGNAL_FWD_HPP
 
 
 
namespace entt {
 
 
template<typename Function>
class sink;
 
 
template<typename Function>
class sigh;
 
 
template<typename Ret, typename... Args>
class sigh<Ret(Args...)> {
    friend class sink<Ret(Args...)>;
 
public:
    using size_type = std::size_t;
    using sink_type = entt::sink<Ret(Args...)>;
 
    template<typename Class>
    using instance_type = Class *;
 
    size_type size() const ENTT_NOEXCEPT {
        return calls.size();
    }
 
    bool empty() const ENTT_NOEXCEPT {
        return calls.empty();
    }
 
    void publish(Args... args) const {
        std::for_each(calls.cbegin(), calls.cend(), [&args...](auto &&call) {
            call(args...);
        });
    }
 
    template<typename Func>
    void collect(Func func, Args... args) const {
        for(auto &&call: calls) {
            if constexpr(std::is_void_v<Ret>) {
                if constexpr(std::is_invocable_r_v<bool, Func>) {
                    call(args...);
                    if(func()) { break; }
                } else {
                    call(args...);
                    func();
                }
            } else {
                if constexpr(std::is_invocable_r_v<bool, Func, Ret>) {
                    if(func(call(args...))) { break; }
                } else {
                    func(call(args...));
                }
            }
        }
    }
 
private:
    std::vector<delegate<Ret(Args...)>> calls;
};
 
 
class connection {
    template<typename>
    friend class sink;
 
    connection(delegate<void(void *)> fn, void *ref)
        : disconnect{fn}, signal{ref}
    {}
 
public:
    connection() = default;
 
    connection(const connection &) = default;
 
    connection(connection &&other)
        : connection{}
    {
        std::swap(disconnect, other.disconnect);
        std::swap(signal, other.signal);
    }
 
    connection & operator=(const connection &) = default;
 
    connection & operator=(connection &&other) {
        if(this != &other) {
            auto tmp{std::move(other)};
            disconnect = tmp.disconnect;
            signal = tmp.signal;
        }
 
        return *this;
    }
 
    explicit operator bool() const ENTT_NOEXCEPT {
        return static_cast<bool>(disconnect);
    }
 
    void release() {
        if(disconnect) {
            disconnect(signal);
            disconnect.reset();
        }
    }
 
private:
    delegate<void(void *)> disconnect;
    void *signal{};
};
 
 
struct scoped_connection: private connection {
    using connection::operator bool;
    using connection::release;
 
    scoped_connection() = default;
 
    scoped_connection(const connection &conn)
        : connection{conn}
    {}
 
    scoped_connection(const scoped_connection &) = delete;
 
    scoped_connection(scoped_connection &&) = default;
 
    ~scoped_connection() {
        connection::release();
    }
 
    scoped_connection & operator=(const scoped_connection &) = delete;
 
    scoped_connection & operator=(scoped_connection &&) = default;
 
    scoped_connection & operator=(const connection &other) {
        static_cast<connection &>(*this) = other;
        return *this;
    }
 
    scoped_connection & operator=(connection &&other) {
        static_cast<connection &>(*this) = std::move(other);
        return *this;
    }
};
 
 
template<typename Ret, typename... Args>
class sink<Ret(Args...)> {
    using signal_type = sigh<Ret(Args...)>;
    using difference_type = typename std::iterator_traits<typename decltype(signal_type::calls)::iterator>::difference_type;
 
    template<auto Candidate, typename Type>
    static void release(Type value_or_instance, void *signal) {
        sink{*static_cast<signal_type *>(signal)}.disconnect<Candidate>(value_or_instance);
    }
 
    template<auto Function>
    static void release(void *signal) {
        sink{*static_cast<signal_type *>(signal)}.disconnect<Function>();
    }
 
public:
    sink(sigh<Ret(Args...)> &ref) ENTT_NOEXCEPT
        : offset{},
          signal{&ref}
    {}
 
    bool empty() const ENTT_NOEXCEPT {
        return signal->calls.empty();
    }
 
    template<auto Function>
    sink before() {
        delegate<Ret(Args...)> call{};
        call.template connect<Function>();
 
        const auto &calls = signal->calls;
        const auto it = std::find(calls.cbegin(), calls.cend(), std::move(call));
 
        sink other{*this};
        other.offset = std::distance(it, calls.cend());
        return other;
    }
 
    template<auto Candidate, typename Type>
    sink before(Type &value_or_instance) {
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
 
        const auto &calls = signal->calls;
        const auto it = std::find(calls.cbegin(), calls.cend(), std::move(call));
 
        sink other{*this};
        other.offset = std::distance(it, calls.cend());
        return other;
    }
 
    template<auto Candidate, typename Type>
    sink before(Type *value_or_instance) {
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
 
        const auto &calls = signal->calls;
        const auto it = std::find(calls.cbegin(), calls.cend(), std::move(call));
 
        sink other{*this};
        other.offset = std::distance(it, calls.cend());
        return other;
    }
 
    template<typename Type>
    sink before(Type &value_or_instance) {
        return before(&value_or_instance);
    }
 
    template<typename Type>
    sink before(Type *value_or_instance) {
        sink other{*this};
 
        if(value_or_instance) {
            const auto &calls = signal->calls;
            const auto it = std::find_if(calls.cbegin(), calls.cend(), [value_or_instance](const auto &delegate) {
                return delegate.instance() == value_or_instance;
            });
 
            other.offset = std::distance(it, calls.cend());
        }
 
        return other;
    }
 
    sink before() {
        sink other{*this};
        other.offset = signal->calls.size();
        return other;
    }
 
    template<auto Function>
    connection connect() {
        disconnect<Function>();
 
        delegate<Ret(Args...)> call{};
        call.template connect<Function>();
        signal->calls.insert(signal->calls.end() - offset, std::move(call));
 
        delegate<void(void *)> conn{};
        conn.template connect<&release<Function>>();
        return { std::move(conn), signal };
    }
 
    template<auto Candidate, typename Type>
    connection connect(Type &value_or_instance) {
        disconnect<Candidate>(value_or_instance);
 
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
        signal->calls.insert(signal->calls.end() - offset, std::move(call));
 
        delegate<void(void *)> conn{};
        conn.template connect<&release<Candidate, Type &>>(value_or_instance);
        return { std::move(conn), signal };
    }
 
    template<auto Candidate, typename Type>
    connection connect(Type *value_or_instance) {
        disconnect<Candidate>(value_or_instance);
 
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
        signal->calls.insert(signal->calls.end() - offset, std::move(call));
 
        delegate<void(void *)> conn{};
        conn.template connect<&release<Candidate, Type *>>(value_or_instance);
        return { std::move(conn), signal };
    }
 
    template<auto Function>
    void disconnect() {
        auto &calls = signal->calls;
        delegate<Ret(Args...)> call{};
        call.template connect<Function>();
        calls.erase(std::remove(calls.begin(), calls.end(), std::move(call)), calls.end());
    }
 
    template<auto Candidate, typename Type>
    void disconnect(Type &value_or_instance) {
        auto &calls = signal->calls;
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
        calls.erase(std::remove(calls.begin(), calls.end(), std::move(call)), calls.end());
    }
 
    template<auto Candidate, typename Type>
    void disconnect(Type *value_or_instance) {
        auto &calls = signal->calls;
        delegate<Ret(Args...)> call{};
        call.template connect<Candidate>(value_or_instance);
        calls.erase(std::remove(calls.begin(), calls.end(), std::move(call)), calls.end());
    }
 
    template<typename Type>
    void disconnect(Type &value_or_instance) {
        disconnect(&value_or_instance);
    }
 
    template<typename Type>
    void disconnect(Type *value_or_instance) {
        if(value_or_instance) {
            auto &calls = signal->calls;
            calls.erase(std::remove_if(calls.begin(), calls.end(), [value_or_instance](const auto &delegate) {
                return delegate.instance() == value_or_instance;
            }), calls.end());
        }
    }
 
    void disconnect() {
        signal->calls.clear();
    }
 
private:
    difference_type offset;
    signal_type *signal;
};
 
 
template<typename Ret, typename... Args>
sink(sigh<Ret(Args...)> &) ENTT_NOEXCEPT -> sink<Ret(Args...)>;
 
 
}
 
 
#endif // ENTT_SIGNAL_SIGH_HPP
 
 
 
namespace entt {
 
 
class dispatcher {
    using event_family = family<struct internal_dispatcher_event_family>;
 
    template<typename Class, typename Event>
    using instance_type = typename sigh<void(const Event &)>::template instance_type<Class>;
 
    struct base_wrapper {
        virtual ~base_wrapper() = default;
        virtual void publish() = 0;
        virtual void clear() = 0;
    };
 
    template<typename Event>
    struct signal_wrapper: base_wrapper {
        using signal_type = sigh<void(const Event &)>;
        using sink_type = typename signal_type::sink_type;
 
        void publish() override {
            const auto length = events.size();
 
            for(std::size_t pos{}; pos < length; ++pos) {
                signal.publish(events[pos]);
            }
 
            events.erase(events.cbegin(), events.cbegin()+length);
        }
 
        void clear() override {
            events.clear();
        }
 
        sink_type sink() ENTT_NOEXCEPT {
            return entt::sink{signal};
        }
 
        template<typename... Args>
        void trigger(Args &&... args) {
            signal.publish({ std::forward<Args>(args)... });
        }
 
        template<typename... Args>
        void enqueue(Args &&... args) {
            events.emplace_back(std::forward<Args>(args)...);
        }
 
    private:
        signal_type signal{};
        std::vector<Event> events;
    };
 
    struct wrapper_data {
        std::unique_ptr<base_wrapper> wrapper;
        ENTT_ID_TYPE runtime_type;
    };
 
    template<typename Event>
    static auto type() ENTT_NOEXCEPT {
        if constexpr(is_named_type_v<Event>) {
            return named_type_traits_v<Event>;
        } else {
            return event_family::type<std::decay_t<Event>>;
        }
    }
 
    template<typename Event>
    signal_wrapper<Event> & assure() {
        const auto wtype = type<Event>();
        wrapper_data *wdata = nullptr;
 
        if constexpr(is_named_type_v<Event>) {
            const auto it = std::find_if(wrappers.begin(), wrappers.end(), [wtype](const auto &candidate) {
                return candidate.wrapper && candidate.runtime_type == wtype;
            });
 
            wdata = (it == wrappers.cend() ? &wrappers.emplace_back() : &(*it));
        } else {
            if(!(wtype < wrappers.size())) {
                wrappers.resize(wtype+1);
            }
 
            wdata = &wrappers[wtype];
 
            if(wdata->wrapper && wdata->runtime_type != wtype) {
                wrappers.emplace_back();
                std::swap(wrappers[wtype], wrappers.back());
                wdata = &wrappers[wtype];
            }
        }
 
        if(!wdata->wrapper) {
            wdata->wrapper = std::make_unique<signal_wrapper<Event>>();
            wdata->runtime_type = wtype;
        }
 
        return static_cast<signal_wrapper<Event> &>(*wdata->wrapper);
    }
 
public:
    template<typename Event>
    using sink_type = typename signal_wrapper<Event>::sink_type;
 
    template<typename Event>
    sink_type<Event> sink() ENTT_NOEXCEPT {
        return assure<Event>().sink();
    }
 
    template<typename Event, typename... Args>
    void trigger(Args &&... args) {
        assure<Event>().trigger(std::forward<Args>(args)...);
    }
 
    template<typename Event>
    void trigger(Event &&event) {
        assure<std::decay_t<Event>>().trigger(std::forward<Event>(event));
    }
 
    template<typename Event, typename... Args>
    void enqueue(Args &&... args) {
        assure<Event>().enqueue(std::forward<Args>(args)...);
    }
 
    template<typename Event>
    void enqueue(Event &&event) {
        assure<std::decay_t<Event>>().enqueue(std::forward<Event>(event));
    }
 
    template<typename... Event>
    void discard() {
        if constexpr(sizeof...(Event) == 0) {
            std::for_each(wrappers.begin(), wrappers.end(), [](auto &&wdata) {
                if(wdata.wrapper) {
                    wdata.wrapper->clear();
                }
            });
        } else {
            (assure<std::decay_t<Event>>().clear(), ...);
        }
    }
 
    template<typename Event>
    void update() {
        assure<Event>().publish();
    }
 
    void update() const {
        for(auto pos = wrappers.size(); pos; --pos) {
            if(auto &wdata = wrappers[pos-1]; wdata.wrapper) {
                wdata.wrapper->publish();
            }
        }
    }
 
private:
    std::vector<wrapper_data> wrappers;
};
 
 
}
 
 
#endif // ENTT_SIGNAL_DISPATCHER_HPP
 
// #include "signal/emitter.hpp"
#ifndef ENTT_SIGNAL_EMITTER_HPP
#define ENTT_SIGNAL_EMITTER_HPP
 
 
#include <type_traits>
#include <functional>
#include <algorithm>
#include <utility>
#include <memory>
#include <vector>
#include <list>
// #include "../config/config.h"
 
// #include "../core/family.hpp"
 
// #include "../core/type_traits.hpp"
 
 
 
namespace entt {
 
 
template<typename Derived>
class emitter {
    using handler_family = family<struct internal_emitter_handler_family>;
 
    struct base_handler {
        virtual ~base_handler() = default;
        virtual bool empty() const ENTT_NOEXCEPT = 0;
        virtual void clear() ENTT_NOEXCEPT = 0;
    };
 
    template<typename Event>
    struct event_handler: base_handler {
        using listener_type = std::function<void(const Event &, Derived &)>;
        using element_type = std::pair<bool, listener_type>;
        using container_type = std::list<element_type>;
        using connection_type = typename container_type::iterator;
 
        bool empty() const ENTT_NOEXCEPT override {
            auto pred = [](auto &&element) { return element.first; };
 
            return std::all_of(once_list.cbegin(), once_list.cend(), pred) &&
                    std::all_of(on_list.cbegin(), on_list.cend(), pred);
        }
 
        void clear() ENTT_NOEXCEPT override {
            if(publishing) {
                auto func = [](auto &&element) { element.first = true; };
                std::for_each(once_list.begin(), once_list.end(), func);
                std::for_each(on_list.begin(), on_list.end(), func);
            } else {
                once_list.clear();
                on_list.clear();
            }
        }
 
        connection_type once(listener_type listener) {
            return once_list.emplace(once_list.cend(), false, std::move(listener));
        }
 
        connection_type on(listener_type listener) {
            return on_list.emplace(on_list.cend(), false, std::move(listener));
        }
 
        void erase(connection_type conn) ENTT_NOEXCEPT {
            conn->first = true;
 
            if(!publishing) {
                auto pred = [](auto &&element) { return element.first; };
                once_list.remove_if(pred);
                on_list.remove_if(pred);
            }
        }
 
        void publish(const Event &event, Derived &ref) {
            container_type swap_list;
            once_list.swap(swap_list);
 
            auto func = [&event, &ref](auto &&element) {
                return element.first ? void() : element.second(event, ref);
            };
 
            publishing = true;
 
            std::for_each(on_list.rbegin(), on_list.rend(), func);
            std::for_each(swap_list.rbegin(), swap_list.rend(), func);
 
            publishing = false;
 
            on_list.remove_if([](auto &&element) { return element.first; });
        }
 
    private:
        bool publishing{false};
        container_type once_list{};
        container_type on_list{};
    };
 
    struct handler_data {
        std::unique_ptr<base_handler> handler;
        ENTT_ID_TYPE runtime_type;
    };
 
    template<typename Event>
    static auto type() ENTT_NOEXCEPT {
        if constexpr(is_named_type_v<Event>) {
            return named_type_traits_v<Event>;
        } else {
            return handler_family::type<std::decay_t<Event>>;
        }
    }
 
    template<typename Event>
    event_handler<Event> * assure() const ENTT_NOEXCEPT {
        const auto htype = type<Event>();
        handler_data *hdata = nullptr;
 
        if constexpr(is_named_type_v<Event>) {
            const auto it = std::find_if(handlers.begin(), handlers.end(), [htype](const auto &candidate) {
                return candidate.handler && candidate.runtime_type == htype;
            });
 
            hdata = (it == handlers.cend() ? &handlers.emplace_back() : &(*it));
        } else {
            if(!(htype < handlers.size())) {
                handlers.resize(htype+1);
            }
 
            hdata = &handlers[htype];
 
            if(hdata->handler && hdata->runtime_type != htype) {
                handlers.emplace_back();
                std::swap(handlers[htype], handlers.back());
                hdata = &handlers[htype];
            }
        }
 
        if(!hdata->handler) {
            hdata->handler = std::make_unique<event_handler<Event>>();
            hdata->runtime_type = htype;
        }
 
        return static_cast<event_handler<Event> *>(hdata->handler.get());
    }
 
public:
    template<typename Event>
    using listener = typename event_handler<Event>::listener_type;
 
    template<typename Event>
    struct connection: private event_handler<Event>::connection_type {
        friend class emitter;
 
        connection() ENTT_NOEXCEPT = default;
 
        connection(typename event_handler<Event>::connection_type conn)
            : event_handler<Event>::connection_type{std::move(conn)}
        {}
    };
 
    emitter() ENTT_NOEXCEPT = default;
 
    virtual ~emitter() ENTT_NOEXCEPT {
        static_assert(std::is_base_of_v<emitter<Derived>, Derived>);
    }
 
    emitter(emitter &&) = default;
 
    emitter & operator=(emitter &&) = default;
 
    template<typename Event, typename... Args>
    void publish(Args &&... args) {
        assure<Event>()->publish({ std::forward<Args>(args)... }, *static_cast<Derived *>(this));
    }
 
    template<typename Event>
    connection<Event> on(listener<Event> instance) {
        return assure<Event>()->on(std::move(instance));
    }
 
    template<typename Event>
    connection<Event> once(listener<Event> instance) {
        return assure<Event>()->once(std::move(instance));
    }
 
    template<typename Event>
    void erase(connection<Event> conn) ENTT_NOEXCEPT {
        assure<Event>()->erase(std::move(conn));
    }
 
    template<typename Event>
    void clear() ENTT_NOEXCEPT {
        assure<Event>()->clear();
    }
 
    void clear() ENTT_NOEXCEPT {
        std::for_each(handlers.begin(), handlers.end(), [](auto &&hdata) {
            return hdata.handler ? hdata.handler->clear() : void();
        });
    }
 
    template<typename Event>
    bool empty() const ENTT_NOEXCEPT {
        return assure<Event>()->empty();
    }
 
    bool empty() const ENTT_NOEXCEPT {
        return std::all_of(handlers.cbegin(), handlers.cend(), [](auto &&hdata) {
            return !hdata.handler || hdata.handler->empty();
        });
    }
 
private:
    mutable std::vector<handler_data> handlers{};
};
 
 
}
 
 
#endif // ENTT_SIGNAL_EMITTER_HPP
 
// #include "signal/sigh.hpp"