From 61e5bcef2629e2d68b805a956a96fff264d4f74d Mon Sep 17 00:00:00 2001 From: untodesu Date: Sat, 28 Jun 2025 01:59:49 +0500 Subject: Restructure dependencies and update to C++20 - Nuked static_assert from almost everywhere in the project - Nuked binary dependency support. Might add one later though - Separated dependency headers into a separate include subdirectory - Grafted a thirdpartylegalnotices.txt generator from RITEG - Pushed development snapshot version to 2126 (26th week of 2025) --- deps/include/entt/core/algorithm.hpp | 143 ----- deps/include/entt/core/any.hpp | 513 ---------------- deps/include/entt/core/attribute.h | 30 - deps/include/entt/core/bit.hpp | 69 --- deps/include/entt/core/compressed_pair.hpp | 272 --------- deps/include/entt/core/enum.hpp | 97 --- deps/include/entt/core/family.hpp | 33 -- deps/include/entt/core/fwd.hpp | 36 -- deps/include/entt/core/hashed_string.hpp | 311 ---------- deps/include/entt/core/ident.hpp | 35 -- deps/include/entt/core/iterator.hpp | 197 ------- deps/include/entt/core/memory.hpp | 244 -------- deps/include/entt/core/monostate.hpp | 60 -- deps/include/entt/core/ranges.hpp | 20 - deps/include/entt/core/tuple.hpp | 95 --- deps/include/entt/core/type_info.hpp | 268 --------- deps/include/entt/core/type_traits.hpp | 919 ----------------------------- deps/include/entt/core/utility.hpp | 101 ---- 18 files changed, 3443 deletions(-) delete mode 100644 deps/include/entt/core/algorithm.hpp delete mode 100644 deps/include/entt/core/any.hpp delete mode 100644 deps/include/entt/core/attribute.h delete mode 100644 deps/include/entt/core/bit.hpp delete mode 100644 deps/include/entt/core/compressed_pair.hpp delete mode 100644 deps/include/entt/core/enum.hpp delete mode 100644 deps/include/entt/core/family.hpp delete mode 100644 deps/include/entt/core/fwd.hpp delete mode 100644 deps/include/entt/core/hashed_string.hpp delete mode 100644 deps/include/entt/core/ident.hpp delete mode 100644 deps/include/entt/core/iterator.hpp delete mode 100644 deps/include/entt/core/memory.hpp delete mode 100644 deps/include/entt/core/monostate.hpp delete mode 100644 deps/include/entt/core/ranges.hpp delete mode 100644 deps/include/entt/core/tuple.hpp delete mode 100644 deps/include/entt/core/type_info.hpp delete mode 100644 deps/include/entt/core/type_traits.hpp delete mode 100644 deps/include/entt/core/utility.hpp (limited to 'deps/include/entt/core') diff --git a/deps/include/entt/core/algorithm.hpp b/deps/include/entt/core/algorithm.hpp deleted file mode 100644 index 35bdf94..0000000 --- a/deps/include/entt/core/algorithm.hpp +++ /dev/null @@ -1,143 +0,0 @@ -#ifndef ENTT_CORE_ALGORITHM_HPP -#define ENTT_CORE_ALGORITHM_HPP - -#include -#include -#include -#include -#include -#include "utility.hpp" - -namespace entt { - -/** - * @brief Function object to wrap `std::sort` in a class type. - * - * Unfortunately, `std::sort` cannot be passed as template argument to a class - * template or a function template.
- * This class fills the gap by wrapping some flavors of `std::sort` in a - * function object. - */ -struct std_sort { - /** - * @brief Sorts the elements in a range. - * - * Sorts the elements in a range using the given binary comparison function. - * - * @tparam It Type of random access iterator. - * @tparam Compare Type of comparison function object. - * @tparam Args Types of arguments to forward to the sort function. - * @param first An iterator to the first element of the range to sort. - * @param last An iterator past the last element of the range to sort. - * @param compare A valid comparison function object. - * @param args Arguments to forward to the sort function, if any. - */ - template, typename... Args> - void operator()(It first, It last, Compare compare = Compare{}, Args &&...args) const { - std::sort(std::forward(args)..., std::move(first), std::move(last), std::move(compare)); - } -}; - -/*! @brief Function object for performing insertion sort. */ -struct insertion_sort { - /** - * @brief Sorts the elements in a range. - * - * Sorts the elements in a range using the given binary comparison function. - * - * @tparam It Type of random access iterator. - * @tparam Compare Type of comparison function object. - * @param first An iterator to the first element of the range to sort. - * @param last An iterator past the last element of the range to sort. - * @param compare A valid comparison function object. - */ - template> - 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; - - // NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic) - for(; pre > first && compare(value, *(pre - 1)); --pre) { - *pre = std::move(*(pre - 1)); - } - // NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic) - - *pre = std::move(value); - } - } - } -}; - -/** - * @brief Function object for performing LSD radix sort. - * @tparam Bit Number of bits processed per pass. - * @tparam N Maximum number of bits to sort. - */ -template -struct radix_sort { - static_assert((N % Bit) == 0, "The maximum number of bits to sort must be a multiple of the number of bits processed per pass"); - - /** - * @brief Sorts the elements in a range. - * - * Sorts the elements in a range using the given _getter_ to access the - * actual data to be sorted. - * - * This implementation is inspired by the online book - * [Physically Based Rendering](http://www.pbr-book.org/3ed-2018/Primitives_and_Intersection_Acceleration/Bounding_Volume_Hierarchies.html#RadixSort). - * - * @tparam It Type of random access iterator. - * @tparam Getter Type of _getter_ function object. - * @param first An iterator to the first element of the range to sort. - * @param last An iterator past the last element of the range to sort. - * @param getter A valid _getter_ function object. - */ - template - void operator()(It first, It last, Getter getter = Getter{}) const { - if(first < last) { - constexpr auto passes = N / Bit; - - using value_type = typename std::iterator_traits::value_type; - std::vector aux(std::distance(first, last)); - - auto part = [getter = std::move(getter)](auto from, auto to, auto out, auto start) { - constexpr auto mask = (1 << Bit) - 1; - constexpr auto buckets = 1 << Bit; - - // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays) - std::size_t count[buckets]{}; - - for(auto it = from; it != to; ++it) { - ++count[(getter(*it) >> start) & mask]; - } - - // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays) - std::size_t index[buckets]{}; - - for(std::size_t pos{}, end = buckets - 1u; pos < end; ++pos) { - index[pos + 1u] = index[pos] + count[pos]; - } - - for(auto it = from; it != to; ++it) { - out[index[(getter(*it) >> start) & mask]++] = std::move(*it); - } - }; - - 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); - } - } - } -}; - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/any.hpp b/deps/include/entt/core/any.hpp deleted file mode 100644 index 9707996..0000000 --- a/deps/include/entt/core/any.hpp +++ /dev/null @@ -1,513 +0,0 @@ -#ifndef ENTT_CORE_ANY_HPP -#define ENTT_CORE_ANY_HPP - -#include -#include -#include -#include -#include "../config/config.h" -#include "../core/utility.hpp" -#include "fwd.hpp" -#include "type_info.hpp" -#include "type_traits.hpp" - -namespace entt { - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -enum class any_operation : std::uint8_t { - copy, - move, - transfer, - assign, - destroy, - compare, - get -}; - -} // namespace internal -/*! @endcond */ - -/*! @brief Possible modes of an any object. */ -enum class any_policy : std::uint8_t { - /*! @brief Default mode, the object owns the contained element. */ - owner, - /*! @brief Aliasing mode, the object _points_ to a non-const element. */ - ref, - /*! @brief Const aliasing mode, the object _points_ to a const element. */ - cref -}; - -/** - * @brief A SBO friendly, type-safe container for single values of any type. - * @tparam Len Size of the storage reserved for the small buffer optimization. - * @tparam Align Optional alignment requirement. - */ -template -class basic_any { - using operation = internal::any_operation; - using vtable_type = const void *(const operation, const basic_any &, const void *); - - struct storage_type { - // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays) - alignas(Align) std::byte data[Len + !Len]; - }; - - template - static constexpr bool in_situ = Len && alignof(Type) <= Align && sizeof(Type) <= Len && std::is_nothrow_move_constructible_v; - - template - static const void *basic_vtable(const operation op, const basic_any &value, const void *other) { - static_assert(!std::is_void_v && std::is_same_v>, Type>, "Invalid type"); - const Type *elem = nullptr; - - if constexpr(in_situ) { - elem = (value.mode == any_policy::owner) ? reinterpret_cast(&value.storage) : static_cast(value.instance); - } else { - elem = static_cast(value.instance); - } - - switch(op) { - case operation::copy: - if constexpr(std::is_copy_constructible_v) { - static_cast(const_cast(other))->initialize(*elem); - } - break; - case operation::move: - if constexpr(in_situ) { - if(value.mode == any_policy::owner) { - return ::new(&static_cast(const_cast(other))->storage) Type{std::move(*const_cast(elem))}; - } - } - - return (static_cast(const_cast(other))->instance = std::exchange(const_cast(value).instance, nullptr)); - case operation::transfer: - if constexpr(std::is_move_assignable_v) { - *const_cast(elem) = std::move(*static_cast(const_cast(other))); - return other; - } - [[fallthrough]]; - case operation::assign: - if constexpr(std::is_copy_assignable_v) { - *const_cast(elem) = *static_cast(other); - return other; - } - break; - case operation::destroy: - if constexpr(in_situ) { - elem->~Type(); - } else if constexpr(std::is_array_v) { - delete[] elem; - } else { - delete elem; - } - break; - case operation::compare: - if constexpr(!std::is_function_v && !std::is_array_v && is_equality_comparable_v) { - return *elem == *static_cast(other) ? other : nullptr; - } else { - return (elem == other) ? other : nullptr; - } - case operation::get: - return elem; - } - - return nullptr; - } - - template - void initialize([[maybe_unused]] Args &&...args) { - using plain_type = std::remove_cv_t>; - info = &type_id(); - - if constexpr(!std::is_void_v) { - vtable = basic_vtable; - - if constexpr(std::is_lvalue_reference_v) { - static_assert((std::is_lvalue_reference_v && ...) && (sizeof...(Args) == 1u), "Invalid arguments"); - mode = std::is_const_v> ? any_policy::cref : any_policy::ref; - instance = (std::addressof(args), ...); - } else if constexpr(in_situ) { - if constexpr(std::is_aggregate_v && (sizeof...(Args) != 0u || !std::is_default_constructible_v)) { - ::new(&storage) plain_type{std::forward(args)...}; - } else { - ::new(&storage) plain_type(std::forward(args)...); - } - } else { - if constexpr(std::is_aggregate_v && (sizeof...(Args) != 0u || !std::is_default_constructible_v)) { - instance = new plain_type{std::forward(args)...}; - } else if constexpr(std::is_array_v) { - static_assert(sizeof...(Args) == 0u, "Invalid arguments"); - instance = new plain_type[std::extent_v](); - } else { - instance = new plain_type(std::forward(args)...); - } - } - } - } - - basic_any(const basic_any &other, const any_policy pol) noexcept - : instance{other.data()}, - info{other.info}, - vtable{other.vtable}, - mode{pol} {} - -public: - /*! @brief Size of the internal storage. */ - static constexpr auto length = Len; - /*! @brief Alignment requirement. */ - static constexpr auto alignment = Align; - - /*! @brief Default constructor. */ - constexpr basic_any() noexcept - : basic_any{std::in_place_type} {} - - /** - * @brief Constructs a wrapper by directly initializing the new object. - * @tparam Type Type of object to use to initialize the wrapper. - * @tparam Args Types of arguments to use to construct the new instance. - * @param args Parameters to use to construct the instance. - */ - template - explicit basic_any(std::in_place_type_t, Args &&...args) - : instance{}, - info{}, - vtable{}, - mode{any_policy::owner} { - initialize(std::forward(args)...); - } - - /** - * @brief Constructs a wrapper from a given value. - * @tparam Type Type of object to use to initialize the wrapper. - * @param value An instance of an object to use to initialize the wrapper. - */ - template, basic_any>>> - basic_any(Type &&value) - : basic_any{std::in_place_type>, std::forward(value)} {} - - /** - * @brief Copy constructor. - * @param other The instance to copy from. - */ - basic_any(const basic_any &other) - : basic_any{} { - if(other.vtable) { - other.vtable(operation::copy, other, this); - } - } - - /** - * @brief Move constructor. - * @param other The instance to move from. - */ - basic_any(basic_any &&other) noexcept - : instance{}, - info{other.info}, - vtable{other.vtable}, - mode{other.mode} { - if(other.vtable) { - other.vtable(operation::move, other, this); - } - } - - /*! @brief Frees the internal storage, whatever it means. */ - ~basic_any() noexcept { - if(vtable && (mode == any_policy::owner)) { - vtable(operation::destroy, *this, nullptr); - } - } - - /** - * @brief Copy assignment operator. - * @param other The instance to copy from. - * @return This any object. - */ - basic_any &operator=(const basic_any &other) { - if(this != &other) { - reset(); - - if(other.vtable) { - other.vtable(operation::copy, other, this); - } - } - - return *this; - } - - /** - * @brief Move assignment operator. - * @param other The instance to move from. - * @return This any object. - */ - basic_any &operator=(basic_any &&other) noexcept { - ENTT_ASSERT(this != &other, "Self move assignment"); - - reset(); - - if(other.vtable) { - other.vtable(operation::move, other, this); - info = other.info; - vtable = other.vtable; - mode = other.mode; - } - - return *this; - } - - /** - * @brief Value assignment operator. - * @tparam Type Type of object to use to initialize the wrapper. - * @param value An instance of an object to use to initialize the wrapper. - * @return This any object. - */ - template, basic_any>>> - basic_any &operator=(Type &&value) { - emplace>(std::forward(value)); - return *this; - } - - /** - * @brief Returns the object type if any, `type_id()` otherwise. - * @return The object type if any, `type_id()` otherwise. - */ - [[nodiscard]] const type_info &type() const noexcept { - return *info; - } - - /** - * @brief Returns an opaque pointer to the contained instance. - * @return An opaque pointer the contained instance, if any. - */ - [[nodiscard]] const void *data() const noexcept { - return vtable ? vtable(operation::get, *this, nullptr) : nullptr; - } - - /** - * @brief Returns an opaque pointer to the contained instance. - * @param req Expected type. - * @return An opaque pointer the contained instance, if any. - */ - [[nodiscard]] const void *data(const type_info &req) const noexcept { - return *info == req ? data() : nullptr; - } - - /** - * @brief Returns an opaque pointer to the contained instance. - * @return An opaque pointer the contained instance, if any. - */ - [[nodiscard]] void *data() noexcept { - return mode == any_policy::cref ? nullptr : const_cast(std::as_const(*this).data()); - } - - /** - * @brief Returns an opaque pointer to the contained instance. - * @param req Expected type. - * @return An opaque pointer the contained instance, if any. - */ - [[nodiscard]] void *data(const type_info &req) noexcept { - return mode == any_policy::cref ? nullptr : const_cast(std::as_const(*this).data(req)); - } - - /** - * @brief Replaces the contained object by creating a new instance directly. - * @tparam Type Type of object to use to initialize the wrapper. - * @tparam Args Types of arguments to use to construct the new instance. - * @param args Parameters to use to construct the instance. - */ - template - void emplace(Args &&...args) { - reset(); - initialize(std::forward(args)...); - } - - /** - * @brief Assigns a value to the contained object without replacing it. - * @param other The value to assign to the contained object. - * @return True in case of success, false otherwise. - */ - bool assign(const basic_any &other) { - if(vtable && mode != any_policy::cref && *info == *other.info) { - return (vtable(operation::assign, *this, other.data()) != nullptr); - } - - return false; - } - - /*! @copydoc assign */ - bool assign(basic_any &&other) { - if(vtable && mode != any_policy::cref && *info == *other.info) { - if(auto *val = other.data(); val) { - return (vtable(operation::transfer, *this, val) != nullptr); - } else { - return (vtable(operation::assign, *this, std::as_const(other).data()) != nullptr); - } - } - - return false; - } - - /*! @brief Destroys contained object */ - void reset() { - if(vtable && (mode == any_policy::owner)) { - vtable(operation::destroy, *this, nullptr); - } - - // unnecessary but it helps to detect nasty bugs - ENTT_ASSERT((instance = nullptr) == nullptr, ""); - info = &type_id(); - vtable = nullptr; - mode = any_policy::owner; - } - - /** - * @brief Returns false if a wrapper is empty, true otherwise. - * @return False if the wrapper is empty, true otherwise. - */ - [[nodiscard]] explicit operator bool() const noexcept { - return vtable != nullptr; - } - - /** - * @brief Checks if two wrappers differ in their content. - * @param other Wrapper with which to compare. - * @return False if the two objects differ in their content, true otherwise. - */ - [[nodiscard]] bool operator==(const basic_any &other) const noexcept { - if(vtable && *info == *other.info) { - return (vtable(operation::compare, *this, other.data()) != nullptr); - } - - return (!vtable && !other.vtable); - } - - /** - * @brief Checks if two wrappers differ in their content. - * @param other Wrapper with which to compare. - * @return True if the two objects differ in their content, false otherwise. - */ - [[nodiscard]] bool operator!=(const basic_any &other) const noexcept { - return !(*this == other); - } - - /** - * @brief Aliasing constructor. - * @return A wrapper that shares a reference to an unmanaged object. - */ - [[nodiscard]] basic_any as_ref() noexcept { - return basic_any{*this, (mode == any_policy::cref ? any_policy::cref : any_policy::ref)}; - } - - /*! @copydoc as_ref */ - [[nodiscard]] basic_any as_ref() const noexcept { - return basic_any{*this, any_policy::cref}; - } - - /** - * @brief Returns the current mode of an any object. - * @return The current mode of the any object. - */ - [[nodiscard]] any_policy policy() const noexcept { - return mode; - } - -private: - union { - const void *instance; - storage_type storage; - }; - const type_info *info; - vtable_type *vtable; - any_policy mode; -}; - -/** - * @brief Performs type-safe access to the contained object. - * @tparam Type Type to which conversion is required. - * @tparam Len Size of the storage reserved for the small buffer optimization. - * @tparam Align Alignment requirement. - * @param data Target any object. - * @return The element converted to the requested type. - */ -template -[[nodiscard]] Type any_cast(const basic_any &data) noexcept { - const auto *const instance = any_cast>(&data); - ENTT_ASSERT(instance, "Invalid instance"); - return static_cast(*instance); -} - -/*! @copydoc any_cast */ -template -[[nodiscard]] Type any_cast(basic_any &data) noexcept { - // forces const on non-reference types to make them work also with wrappers for const references - auto *const instance = any_cast>(&data); - ENTT_ASSERT(instance, "Invalid instance"); - return static_cast(*instance); -} - -/*! @copydoc any_cast */ -template -[[nodiscard]] Type any_cast(basic_any &&data) noexcept { - if constexpr(std::is_copy_constructible_v>>) { - if(auto *const instance = any_cast>(&data); instance) { - return static_cast(std::move(*instance)); - } else { - return any_cast(data); - } - } else { - auto *const instance = any_cast>(&data); - ENTT_ASSERT(instance, "Invalid instance"); - return static_cast(std::move(*instance)); - } -} - -/*! @copydoc any_cast */ -template -[[nodiscard]] const Type *any_cast(const basic_any *data) noexcept { - const auto &info = type_id>(); - return static_cast(data->data(info)); -} - -/*! @copydoc any_cast */ -template -[[nodiscard]] Type *any_cast(basic_any *data) noexcept { - if constexpr(std::is_const_v) { - // last attempt to make wrappers for const references return their values - return any_cast(&std::as_const(*data)); - } else { - const auto &info = type_id>(); - return static_cast(data->data(info)); - } -} - -/** - * @brief Constructs a wrapper from a given type, passing it all arguments. - * @tparam Type Type of object to use to initialize the wrapper. - * @tparam Len Size of the storage reserved for the small buffer optimization. - * @tparam Align Optional alignment requirement. - * @tparam Args Types of arguments to use to construct the new instance. - * @param args Parameters to use to construct the instance. - * @return A properly initialized wrapper for an object of the given type. - */ -template::length, std::size_t Align = basic_any::alignment, typename... Args> -[[nodiscard]] basic_any make_any(Args &&...args) { - return basic_any{std::in_place_type, std::forward(args)...}; -} - -/** - * @brief Forwards its argument and avoids copies for lvalue references. - * @tparam Len Size of the storage reserved for the small buffer optimization. - * @tparam Align Optional alignment requirement. - * @tparam Type Type of argument to use to construct the new instance. - * @param value Parameter to use to construct the instance. - * @return A properly initialized and not necessarily owning wrapper. - */ -template::length, std::size_t Align = basic_any::alignment, typename Type> -[[nodiscard]] basic_any forward_as_any(Type &&value) { - return basic_any{std::in_place_type, std::forward(value)}; -} - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/attribute.h b/deps/include/entt/core/attribute.h deleted file mode 100644 index 2af32d9..0000000 --- a/deps/include/entt/core/attribute.h +++ /dev/null @@ -1,30 +0,0 @@ -#ifndef ENTT_CORE_ATTRIBUTE_H -#define ENTT_CORE_ATTRIBUTE_H - -#ifndef ENTT_EXPORT -# if defined _WIN32 || defined __CYGWIN__ || defined _MSC_VER -# define ENTT_EXPORT __declspec(dllexport) -# define ENTT_IMPORT __declspec(dllimport) -# define ENTT_HIDDEN -# elif defined __GNUC__ && __GNUC__ >= 4 -# define ENTT_EXPORT __attribute__((visibility("default"))) -# define ENTT_IMPORT __attribute__((visibility("default"))) -# define ENTT_HIDDEN __attribute__((visibility("hidden"))) -# else /* Unsupported compiler */ -# define ENTT_EXPORT -# define ENTT_IMPORT -# define ENTT_HIDDEN -# endif -#endif - -#ifndef ENTT_API -# if defined ENTT_API_EXPORT -# define ENTT_API ENTT_EXPORT -# elif defined ENTT_API_IMPORT -# define ENTT_API ENTT_IMPORT -# else /* No API */ -# define ENTT_API -# endif -#endif - -#endif diff --git a/deps/include/entt/core/bit.hpp b/deps/include/entt/core/bit.hpp deleted file mode 100644 index 6a28058..0000000 --- a/deps/include/entt/core/bit.hpp +++ /dev/null @@ -1,69 +0,0 @@ -#ifndef ENTT_CORE_BIT_HPP -#define ENTT_CORE_BIT_HPP - -#include -#include -#include -#include "../config/config.h" - -namespace entt { - -/** - * @brief Returns the number of set bits in a value (waiting for C++20 and - * `std::popcount`). - * @tparam Type Unsigned integer type. - * @param value A value of unsigned integer type. - * @return The number of set bits in the value. - */ -template -[[nodiscard]] constexpr std::enable_if_t, int> popcount(const Type value) noexcept { - return value ? (int(value & 1) + popcount(static_cast(value >> 1))) : 0; -} - -/** - * @brief Checks whether a value is a power of two or not (waiting for C++20 and - * `std::has_single_bit`). - * @tparam Type Unsigned integer type. - * @param value A value of unsigned integer type. - * @return True if the value is a power of two, false otherwise. - */ -template -[[nodiscard]] constexpr std::enable_if_t, bool> has_single_bit(const Type value) noexcept { - return value && ((value & (value - 1)) == 0); -} - -/** - * @brief Computes the smallest power of two greater than or equal to a value - * (waiting for C++20 and `std::bit_ceil`). - * @tparam Type Unsigned integer type. - * @param value A value of unsigned integer type. - * @return The smallest power of two greater than or equal to the given value. - */ -template -[[nodiscard]] constexpr std::enable_if_t, Type> next_power_of_two(const Type value) noexcept { - ENTT_ASSERT_CONSTEXPR(value < (Type{1u} << (std::numeric_limits::digits - 1)), "Numeric limits exceeded"); - Type curr = value - (value != 0u); - - for(int next = 1; next < std::numeric_limits::digits; next = next * 2) { - curr |= (curr >> next); - } - - return ++curr; -} - -/** - * @brief Fast module utility function (powers of two only). - * @tparam Type Unsigned integer type. - * @param value A value of unsigned integer type. - * @param mod _Modulus_, it must be a power of two. - * @return The common remainder. - */ -template -[[nodiscard]] constexpr std::enable_if_t, Type> fast_mod(const Type value, const std::size_t mod) noexcept { - ENTT_ASSERT_CONSTEXPR(has_single_bit(mod), "Value must be a power of two"); - return value & (mod - 1u); -} - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/compressed_pair.hpp b/deps/include/entt/core/compressed_pair.hpp deleted file mode 100644 index a10589f..0000000 --- a/deps/include/entt/core/compressed_pair.hpp +++ /dev/null @@ -1,272 +0,0 @@ -#ifndef ENTT_CORE_COMPRESSED_PAIR_HPP -#define ENTT_CORE_COMPRESSED_PAIR_HPP - -#include -#include -#include -#include -#include "fwd.hpp" -#include "type_traits.hpp" - -namespace entt { - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -template -struct compressed_pair_element { - using reference = Type &; - using const_reference = const Type &; - - template>> - // NOLINTNEXTLINE(modernize-use-equals-default) - constexpr compressed_pair_element() noexcept(std::is_nothrow_default_constructible_v) {} - - template>, compressed_pair_element>>> - constexpr compressed_pair_element(Arg &&arg) noexcept(std::is_nothrow_constructible_v) - : value{std::forward(arg)} {} - - template - constexpr compressed_pair_element(std::tuple args, std::index_sequence) noexcept(std::is_nothrow_constructible_v) - : value{std::forward(std::get(args))...} {} - - [[nodiscard]] constexpr reference get() noexcept { - return value; - } - - [[nodiscard]] constexpr const_reference get() const noexcept { - return value; - } - -private: - Type value{}; -}; - -template -struct compressed_pair_element>>: Type { - using reference = Type &; - using const_reference = const Type &; - using base_type = Type; - - template>> - constexpr compressed_pair_element() noexcept(std::is_nothrow_default_constructible_v) - : base_type{} {} - - template>, compressed_pair_element>>> - constexpr compressed_pair_element(Arg &&arg) noexcept(std::is_nothrow_constructible_v) - : base_type{std::forward(arg)} {} - - template - constexpr compressed_pair_element(std::tuple args, std::index_sequence) noexcept(std::is_nothrow_constructible_v) - : base_type{std::forward(std::get(args))...} {} - - [[nodiscard]] constexpr reference get() noexcept { - return *this; - } - - [[nodiscard]] constexpr const_reference get() const noexcept { - return *this; - } -}; - -} // namespace internal -/*! @endcond */ - -/** - * @brief A compressed pair. - * - * A pair that exploits the _Empty Base Class Optimization_ (or _EBCO_) to - * reduce its final size to a minimum. - * - * @tparam First The type of the first element that the pair stores. - * @tparam Second The type of the second element that the pair stores. - */ -template -class compressed_pair final - : internal::compressed_pair_element, - internal::compressed_pair_element { - using first_base = internal::compressed_pair_element; - using second_base = internal::compressed_pair_element; - -public: - /*! @brief The type of the first element that the pair stores. */ - using first_type = First; - /*! @brief The type of the second element that the pair stores. */ - using second_type = Second; - - /** - * @brief Default constructor, conditionally enabled. - * - * This constructor is only available when the types that the pair stores - * are both at least default constructible. - * - * @tparam Dummy Dummy template parameter used for internal purposes. - */ - template && std::is_default_constructible_v>> - constexpr compressed_pair() noexcept(std::is_nothrow_default_constructible_v && std::is_nothrow_default_constructible_v) - : first_base{}, - second_base{} {} - - /** - * @brief Copy constructor. - * @param other The instance to copy from. - */ - constexpr compressed_pair(const compressed_pair &other) noexcept(std::is_nothrow_copy_constructible_v && std::is_nothrow_copy_constructible_v) = default; - - /** - * @brief Move constructor. - * @param other The instance to move from. - */ - constexpr compressed_pair(compressed_pair &&other) noexcept(std::is_nothrow_move_constructible_v && std::is_nothrow_move_constructible_v) = default; - - /** - * @brief Constructs a pair from its values. - * @tparam Arg Type of value to use to initialize the first element. - * @tparam Other Type of value to use to initialize the second element. - * @param arg Value to use to initialize the first element. - * @param other Value to use to initialize the second element. - */ - template - constexpr compressed_pair(Arg &&arg, Other &&other) noexcept(std::is_nothrow_constructible_v && std::is_nothrow_constructible_v) - : first_base{std::forward(arg)}, - second_base{std::forward(other)} {} - - /** - * @brief Constructs a pair by forwarding the arguments to its parts. - * @tparam Args Types of arguments to use to initialize the first element. - * @tparam Other Types of arguments to use to initialize the second element. - * @param args Arguments to use to initialize the first element. - * @param other Arguments to use to initialize the second element. - */ - template - constexpr compressed_pair(std::piecewise_construct_t, std::tuple args, std::tuple other) noexcept(std::is_nothrow_constructible_v && std::is_nothrow_constructible_v) - : first_base{std::move(args), std::index_sequence_for{}}, - second_base{std::move(other), std::index_sequence_for{}} {} - - /*! @brief Default destructor. */ - ~compressed_pair() noexcept(std::is_nothrow_destructible_v && std::is_nothrow_destructible_v) = default; - - /** - * @brief Copy assignment operator. - * @param other The instance to copy from. - * @return This compressed pair object. - */ - constexpr compressed_pair &operator=(const compressed_pair &other) noexcept(std::is_nothrow_copy_assignable_v && std::is_nothrow_copy_assignable_v) = default; - - /** - * @brief Move assignment operator. - * @param other The instance to move from. - * @return This compressed pair object. - */ - constexpr compressed_pair &operator=(compressed_pair &&other) noexcept(std::is_nothrow_move_assignable_v && std::is_nothrow_move_assignable_v) = default; - - /** - * @brief Returns the first element that a pair stores. - * @return The first element that a pair stores. - */ - [[nodiscard]] constexpr first_type &first() noexcept { - return static_cast(*this).get(); - } - - /*! @copydoc first */ - [[nodiscard]] constexpr const first_type &first() const noexcept { - return static_cast(*this).get(); - } - - /** - * @brief Returns the second element that a pair stores. - * @return The second element that a pair stores. - */ - [[nodiscard]] constexpr second_type &second() noexcept { - return static_cast(*this).get(); - } - - /*! @copydoc second */ - [[nodiscard]] constexpr const second_type &second() const noexcept { - return static_cast(*this).get(); - } - - /** - * @brief Swaps two compressed pair objects. - * @param other The compressed pair to swap with. - */ - constexpr void swap(compressed_pair &other) noexcept(std::is_nothrow_swappable_v && std::is_nothrow_swappable_v) { - using std::swap; - swap(first(), other.first()); - swap(second(), other.second()); - } - - /** - * @brief Extracts an element from the compressed pair. - * @tparam Index An integer value that is either 0 or 1. - * @return Returns a reference to the first element if `Index` is 0 and a - * reference to the second element if `Index` is 1. - */ - template - [[nodiscard]] constexpr decltype(auto) get() noexcept { - if constexpr(Index == 0u) { - return first(); - } else { - static_assert(Index == 1u, "Index out of bounds"); - return second(); - } - } - - /*! @copydoc get */ - template - [[nodiscard]] constexpr decltype(auto) get() const noexcept { - if constexpr(Index == 0u) { - return first(); - } else { - static_assert(Index == 1u, "Index out of bounds"); - return second(); - } - } -}; - -/** - * @brief Deduction guide. - * @tparam Type Type of value to use to initialize the first element. - * @tparam Other Type of value to use to initialize the second element. - */ -template -compressed_pair(Type &&, Other &&) -> compressed_pair, std::decay_t>; - -/** - * @brief Swaps two compressed pair objects. - * @tparam First The type of the first element that the pairs store. - * @tparam Second The type of the second element that the pairs store. - * @param lhs A valid compressed pair object. - * @param rhs A valid compressed pair object. - */ -template -inline constexpr void swap(compressed_pair &lhs, compressed_pair &rhs) { - lhs.swap(rhs); -} - -} // namespace entt - -namespace std { - -/** - * @brief `std::tuple_size` specialization for `compressed_pair`s. - * @tparam First The type of the first element that the pair stores. - * @tparam Second The type of the second element that the pair stores. - */ -template -struct tuple_size>: integral_constant {}; - -/** - * @brief `std::tuple_element` specialization for `compressed_pair`s. - * @tparam Index The index of the type to return. - * @tparam First The type of the first element that the pair stores. - * @tparam Second The type of the second element that the pair stores. - */ -template -struct tuple_element>: conditional { - static_assert(Index < 2u, "Index out of bounds"); -}; - -} // namespace std - -#endif diff --git a/deps/include/entt/core/enum.hpp b/deps/include/entt/core/enum.hpp deleted file mode 100644 index c78ad5a..0000000 --- a/deps/include/entt/core/enum.hpp +++ /dev/null @@ -1,97 +0,0 @@ -#ifndef ENTT_CORE_ENUM_HPP -#define ENTT_CORE_ENUM_HPP - -#include - -namespace entt { - -/** - * @brief Enable bitmask support for enum classes. - * @tparam Type The enum type for which to enable bitmask support. - */ -template -struct enum_as_bitmask: std::false_type {}; - -/*! @copydoc enum_as_bitmask */ -template -struct enum_as_bitmask>: std::is_enum {}; - -/** - * @brief Helper variable template. - * @tparam Type The enum class type for which to enable bitmask support. - */ -template -inline constexpr bool enum_as_bitmask_v = enum_as_bitmask::value; - -} // namespace entt - -/** - * @brief Operator available for enums for which bitmask support is enabled. - * @tparam Type Enum class type. - * @param lhs The first value to use. - * @param rhs The second value to use. - * @return The result of invoking the operator on the underlying types of the - * two values provided. - */ -template -[[nodiscard]] constexpr std::enable_if_t, Type> -operator|(const Type lhs, const Type rhs) noexcept { - return static_cast(static_cast>(lhs) | static_cast>(rhs)); -} - -/*! @copydoc operator| */ -template -[[nodiscard]] constexpr std::enable_if_t, Type> -operator&(const Type lhs, const Type rhs) noexcept { - return static_cast(static_cast>(lhs) & static_cast>(rhs)); -} - -/*! @copydoc operator| */ -template -[[nodiscard]] constexpr std::enable_if_t, Type> -operator^(const Type lhs, const Type rhs) noexcept { - return static_cast(static_cast>(lhs) ^ static_cast>(rhs)); -} - -/** - * @brief Operator available for enums for which bitmask support is enabled. - * @tparam Type Enum class type. - * @param value The value to use. - * @return The result of invoking the operator on the underlying types of the - * value provided. - */ -template -[[nodiscard]] constexpr std::enable_if_t, Type> -operator~(const Type value) noexcept { - return static_cast(~static_cast>(value)); -} - -/*! @copydoc operator~ */ -template -[[nodiscard]] constexpr std::enable_if_t, bool> -operator!(const Type value) noexcept { - return !static_cast>(value); -} - -/*! @copydoc operator| */ -template -constexpr std::enable_if_t, Type &> -operator|=(Type &lhs, const Type rhs) noexcept { - return (lhs = (lhs | rhs)); -} - -/*! @copydoc operator| */ -template -constexpr std::enable_if_t, Type &> -operator&=(Type &lhs, const Type rhs) noexcept { - return (lhs = (lhs & rhs)); -} - -/*! @copydoc operator| */ -template -constexpr std::enable_if_t, Type &> -operator^=(Type &lhs, const Type rhs) noexcept { - return (lhs = (lhs ^ rhs)); -} - -#endif diff --git a/deps/include/entt/core/family.hpp b/deps/include/entt/core/family.hpp deleted file mode 100644 index 7c7f3e1..0000000 --- a/deps/include/entt/core/family.hpp +++ /dev/null @@ -1,33 +0,0 @@ -#ifndef ENTT_CORE_FAMILY_HPP -#define ENTT_CORE_FAMILY_HPP - -#include "../config/config.h" -#include "fwd.hpp" - -namespace entt { - -/** - * @brief Dynamic identifier generator. - * - * Utility class template that can be used to assign unique identifiers to types - * at runtime. Use different specializations to create separate sets of - * identifiers. - */ -template -class family { - // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - inline static ENTT_MAYBE_ATOMIC(id_type) identifier{}; - -public: - /*! @brief Unsigned integer type. */ - using value_type = id_type; - - /*! @brief Statically generated unique identifier for the given type. */ - template - // at the time I'm writing, clang crashes during compilation if auto is used instead of family_type - inline static const value_type value = identifier++; -}; - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/fwd.hpp b/deps/include/entt/core/fwd.hpp deleted file mode 100644 index 8760a85..0000000 --- a/deps/include/entt/core/fwd.hpp +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef ENTT_CORE_FWD_HPP -#define ENTT_CORE_FWD_HPP - -#include -#include "../config/config.h" - -namespace entt { - -// NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays) -template -class basic_any; - -/*! @brief Alias declaration for type identifiers. */ -using id_type = ENTT_ID_TYPE; - -/*! @brief Alias declaration for the most common use case. */ -using any = basic_any<>; - -template -class compressed_pair; - -template -class basic_hashed_string; - -/*! @brief Aliases for common character types. */ -using hashed_string = basic_hashed_string; - -/*! @brief Aliases for common character types. */ -using hashed_wstring = basic_hashed_string; - -// NOLINTNEXTLINE(bugprone-forward-declaration-namespace) -struct type_info; - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/hashed_string.hpp b/deps/include/entt/core/hashed_string.hpp deleted file mode 100644 index c4b1313..0000000 --- a/deps/include/entt/core/hashed_string.hpp +++ /dev/null @@ -1,311 +0,0 @@ -#ifndef ENTT_CORE_HASHED_STRING_HPP -#define ENTT_CORE_HASHED_STRING_HPP - -#include -#include -#include -#include "fwd.hpp" - -namespace entt { - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -template -struct fnv_1a_params; - -template<> -struct fnv_1a_params { - static constexpr auto offset = 2166136261; - static constexpr auto prime = 16777619; -}; - -template<> -struct fnv_1a_params { - static constexpr auto offset = 14695981039346656037ull; - static constexpr auto prime = 1099511628211ull; -}; - -template -struct basic_hashed_string { - using value_type = Char; - using size_type = std::size_t; - using hash_type = id_type; - - const value_type *repr; - size_type length; - hash_type hash; -}; - -} // namespace internal -/*! @endcond */ - -/** - * @brief Zero overhead unique identifier. - * - * A hashed string is a compile-time tool that allows users to use - * human-readable identifiers in the codebase while using their numeric - * counterparts at runtime.
- * Because of that, a hashed string can also be used in constant expressions if - * required. - * - * @warning - * This class doesn't take ownership of user-supplied strings nor does it make a - * copy of them. - * - * @tparam Char Character type. - */ -template -class basic_hashed_string: internal::basic_hashed_string { - using base_type = internal::basic_hashed_string; - using params = internal::fnv_1a_params<>; - - struct const_wrapper { - // non-explicit constructor on purpose - constexpr const_wrapper(const Char *str) noexcept - : repr{str} {} - - const Char *repr; - }; - - // Fowler–Noll–Vo hash function v. 1a - the good - [[nodiscard]] static constexpr auto helper(const std::basic_string_view view) noexcept { - base_type base{view.data(), view.size(), params::offset}; - - for(auto &&curr: view) { - base.hash = (base.hash ^ static_cast(curr)) * params::prime; - } - - return base; - } - -public: - /*! @brief Character type. */ - using value_type = typename base_type::value_type; - /*! @brief Unsigned integer type. */ - using size_type = typename base_type::size_type; - /*! @brief Unsigned integer type. */ - using hash_type = typename base_type::hash_type; - - /** - * @brief Returns directly the numeric representation of a string view. - * @param str Human-readable identifier. - * @param len Length of the string to hash. - * @return The numeric representation of the string. - */ - [[nodiscard]] static constexpr hash_type value(const value_type *str, const size_type len) noexcept { - return basic_hashed_string{str, len}; - } - - /** - * @brief Returns directly the numeric representation of a string. - * @tparam N Number of characters of the identifier. - * @param str Human-readable identifier. - * @return The numeric representation of the string. - */ - template - // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays) - [[nodiscard]] static constexpr hash_type value(const value_type (&str)[N]) noexcept { - return basic_hashed_string{str}; - } - - /** - * @brief Returns directly the numeric representation of a string. - * @param wrapper Helps achieving the purpose by relying on overloading. - * @return The numeric representation of the string. - */ - [[nodiscard]] static constexpr hash_type value(const_wrapper wrapper) noexcept { - return basic_hashed_string{wrapper}; - } - - /*! @brief Constructs an empty hashed string. */ - constexpr basic_hashed_string() noexcept - : basic_hashed_string{nullptr, 0u} {} - - /** - * @brief Constructs a hashed string from a string view. - * @param str Human-readable identifier. - * @param len Length of the string to hash. - */ - constexpr basic_hashed_string(const value_type *str, const size_type len) noexcept - : base_type{helper({str, len})} {} - - /** - * @brief Constructs a hashed string from an array of const characters. - * @tparam N Number of characters of the identifier. - * @param str Human-readable identifier. - */ - template - // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays) - constexpr basic_hashed_string(const value_type (&str)[N]) noexcept - : base_type{helper({static_cast(str)})} {} - - /** - * @brief Explicit constructor on purpose to avoid constructing a hashed - * string directly from a `const value_type *`. - * - * @warning - * The lifetime of the string is not extended nor is it copied. - * - * @param wrapper Helps achieving the purpose by relying on overloading. - */ - explicit constexpr basic_hashed_string(const_wrapper wrapper) noexcept - : base_type{helper({wrapper.repr})} {} - - /** - * @brief Returns the size a hashed string. - * @return The size of the hashed string. - */ - [[nodiscard]] constexpr size_type size() const noexcept { - return base_type::length; - } - - /** - * @brief Returns the human-readable representation of a hashed string. - * @return The string used to initialize the hashed string. - */ - [[nodiscard]] constexpr const value_type *data() const noexcept { - return base_type::repr; - } - - /** - * @brief Returns the numeric representation of a hashed string. - * @return The numeric representation of the hashed string. - */ - [[nodiscard]] constexpr hash_type value() const noexcept { - return base_type::hash; - } - - /*! @copydoc data */ - [[nodiscard]] constexpr operator const value_type *() const noexcept { - return data(); - } - - /** - * @brief Returns the numeric representation of a hashed string. - * @return The numeric representation of the hashed string. - */ - [[nodiscard]] constexpr operator hash_type() const noexcept { - return value(); - } -}; - -/** - * @brief Deduction guide. - * @tparam Char Character type. - * @param str Human-readable identifier. - * @param len Length of the string to hash. - */ -template -basic_hashed_string(const Char *str, const std::size_t len) -> basic_hashed_string; - -/** - * @brief Deduction guide. - * @tparam Char Character type. - * @tparam N Number of characters of the identifier. - * @param str Human-readable identifier. - */ -template -// NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays, modernize-avoid-c-arrays) -basic_hashed_string(const Char (&str)[N]) -> basic_hashed_string; - -/** - * @brief Compares two hashed strings. - * @tparam Char Character type. - * @param lhs A valid hashed string. - * @param rhs A valid hashed string. - * @return True if the two hashed strings are identical, false otherwise. - */ -template -[[nodiscard]] constexpr bool operator==(const basic_hashed_string &lhs, const basic_hashed_string &rhs) noexcept { - return lhs.value() == rhs.value(); -} - -/** - * @brief Compares two hashed strings. - * @tparam Char Character type. - * @param lhs A valid hashed string. - * @param rhs A valid hashed string. - * @return True if the two hashed strings differ, false otherwise. - */ -template -[[nodiscard]] constexpr bool operator!=(const basic_hashed_string &lhs, const basic_hashed_string &rhs) noexcept { - return !(lhs == rhs); -} - -/** - * @brief Compares two hashed strings. - * @tparam Char Character type. - * @param lhs A valid hashed string. - * @param rhs A valid hashed string. - * @return True if the first element is less than the second, false otherwise. - */ -template -[[nodiscard]] constexpr bool operator<(const basic_hashed_string &lhs, const basic_hashed_string &rhs) noexcept { - return lhs.value() < rhs.value(); -} - -/** - * @brief Compares two hashed strings. - * @tparam Char Character type. - * @param lhs A valid hashed string. - * @param rhs A valid hashed string. - * @return True if the first element is less than or equal to the second, false - * otherwise. - */ -template -[[nodiscard]] constexpr bool operator<=(const basic_hashed_string &lhs, const basic_hashed_string &rhs) noexcept { - return !(rhs < lhs); -} - -/** - * @brief Compares two hashed strings. - * @tparam Char Character type. - * @param lhs A valid hashed string. - * @param rhs A valid hashed string. - * @return True if the first element is greater than the second, false - * otherwise. - */ -template -[[nodiscard]] constexpr bool operator>(const basic_hashed_string &lhs, const basic_hashed_string &rhs) noexcept { - return rhs < lhs; -} - -/** - * @brief Compares two hashed strings. - * @tparam Char Character type. - * @param lhs A valid hashed string. - * @param rhs A valid hashed string. - * @return True if the first element is greater than or equal to the second, - * false otherwise. - */ -template -[[nodiscard]] constexpr bool operator>=(const basic_hashed_string &lhs, const basic_hashed_string &rhs) noexcept { - return !(lhs < rhs); -} - -inline namespace literals { - -/** - * @brief User defined literal for hashed strings. - * @param str The literal without its suffix. - * @return A properly initialized hashed string. - */ -[[nodiscard]] constexpr hashed_string operator"" _hs(const char *str, std::size_t) noexcept { - return hashed_string{str}; -} - -/** - * @brief User defined literal for hashed wstrings. - * @param str The literal without its suffix. - * @return A properly initialized hashed wstring. - */ -[[nodiscard]] constexpr hashed_wstring operator"" _hws(const wchar_t *str, std::size_t) noexcept { - return hashed_wstring{str}; -} - -} // namespace literals - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/ident.hpp b/deps/include/entt/core/ident.hpp deleted file mode 100644 index 5944ea2..0000000 --- a/deps/include/entt/core/ident.hpp +++ /dev/null @@ -1,35 +0,0 @@ -#ifndef ENTT_CORE_IDENT_HPP -#define ENTT_CORE_IDENT_HPP - -#include -#include -#include -#include "fwd.hpp" -#include "type_traits.hpp" - -namespace entt { - -/** - * @brief Type integral identifiers. - * @tparam Type List of types for which to generate identifiers. - */ -template -class ident { - template - [[nodiscard]] static constexpr id_type get(std::index_sequence) noexcept { - static_assert((std::is_same_v || ...), "Invalid type"); - return (0 + ... + (std::is_same_v...>>> ? id_type{Index} : id_type{})); - } - -public: - /*! @brief Unsigned integer type. */ - using value_type = id_type; - - /*! @brief Statically generated unique identifier for the given type. */ - template - static constexpr value_type value = get>(std::index_sequence_for{}); -}; - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/iterator.hpp b/deps/include/entt/core/iterator.hpp deleted file mode 100644 index fdb2ee2..0000000 --- a/deps/include/entt/core/iterator.hpp +++ /dev/null @@ -1,197 +0,0 @@ -#ifndef ENTT_CORE_ITERATOR_HPP -#define ENTT_CORE_ITERATOR_HPP - -#include -#include -#include -#include - -namespace entt { - -/** - * @brief Helper type to use as pointer with input iterators. - * @tparam Type of wrapped value. - */ -template -struct input_iterator_pointer final { - /*! @brief Value type. */ - using value_type = Type; - /*! @brief Pointer type. */ - using pointer = Type *; - /*! @brief Reference type. */ - using reference = Type &; - - /** - * @brief Constructs a proxy object by move. - * @param val Value to use to initialize the proxy object. - */ - constexpr input_iterator_pointer(value_type &&val) noexcept(std::is_nothrow_move_constructible_v) - : value{std::move(val)} {} - - /** - * @brief Access operator for accessing wrapped values. - * @return A pointer to the wrapped value. - */ - [[nodiscard]] constexpr pointer operator->() noexcept { - return std::addressof(value); - } - - /** - * @brief Dereference operator for accessing wrapped values. - * @return A reference to the wrapped value. - */ - [[nodiscard]] constexpr reference operator*() noexcept { - return value; - } - -private: - Type value; -}; - -/** - * @brief Plain iota iterator (waiting for C++20). - * @tparam Type Value type. - */ -template -class iota_iterator final { - static_assert(std::is_integral_v, "Not an integral type"); - -public: - /*! @brief Value type, likely an integral one. */ - using value_type = Type; - /*! @brief Invalid pointer type. */ - using pointer = void; - /*! @brief Non-reference type, same as value type. */ - using reference = value_type; - /*! @brief Difference type. */ - using difference_type = std::ptrdiff_t; - /*! @brief Iterator category. */ - using iterator_category = std::input_iterator_tag; - - /*! @brief Default constructor. */ - constexpr iota_iterator() noexcept - : current{} {} - - /** - * @brief Constructs an iota iterator from a given value. - * @param init The initial value assigned to the iota iterator. - */ - constexpr iota_iterator(const value_type init) noexcept - : current{init} {} - - /** - * @brief Pre-increment operator. - * @return This iota iterator. - */ - constexpr iota_iterator &operator++() noexcept { - return ++current, *this; - } - - /** - * @brief Post-increment operator. - * @return This iota iterator. - */ - constexpr iota_iterator operator++(int) noexcept { - iota_iterator orig = *this; - return ++(*this), orig; - } - - /** - * @brief Dereference operator. - * @return The underlying value. - */ - [[nodiscard]] constexpr reference operator*() const noexcept { - return current; - } - -private: - value_type current; -}; - -/** - * @brief Comparison operator. - * @tparam Type Value type of the iota iterator. - * @param lhs A properly initialized iota iterator. - * @param rhs A properly initialized iota iterator. - * @return True if the two iterators are identical, false otherwise. - */ -template -[[nodiscard]] constexpr bool operator==(const iota_iterator &lhs, const iota_iterator &rhs) noexcept { - return *lhs == *rhs; -} - -/** - * @brief Comparison operator. - * @tparam Type Value type of the iota iterator. - * @param lhs A properly initialized iota iterator. - * @param rhs A properly initialized iota iterator. - * @return True if the two iterators differ, false otherwise. - */ -template -[[nodiscard]] constexpr bool operator!=(const iota_iterator &lhs, const iota_iterator &rhs) noexcept { - return !(lhs == rhs); -} - -/** - * @brief Utility class to create an iterable object from a pair of iterators. - * @tparam It Type of iterator. - * @tparam Sentinel Type of sentinel. - */ -template -struct iterable_adaptor final { - /*! @brief Value type. */ - using value_type = typename std::iterator_traits::value_type; - /*! @brief Iterator type. */ - using iterator = It; - /*! @brief Sentinel type. */ - using sentinel = Sentinel; - - /*! @brief Default constructor. */ - constexpr iterable_adaptor() noexcept(std::is_nothrow_default_constructible_v &&std::is_nothrow_default_constructible_v) - : first{}, - last{} {} - - /** - * @brief Creates an iterable object from a pair of iterators. - * @param from Begin iterator. - * @param to End iterator. - */ - constexpr iterable_adaptor(iterator from, sentinel to) noexcept(std::is_nothrow_move_constructible_v &&std::is_nothrow_move_constructible_v) - : first{std::move(from)}, - last{std::move(to)} {} - - /** - * @brief Returns an iterator to the beginning. - * @return An iterator to the first element of the range. - */ - [[nodiscard]] constexpr iterator begin() const noexcept { - return first; - } - - /** - * @brief Returns an iterator to the end. - * @return An iterator to the element following the last element of the - * range. - */ - [[nodiscard]] constexpr sentinel end() const noexcept { - return last; - } - - /*! @copydoc begin */ - [[nodiscard]] constexpr iterator cbegin() const noexcept { - return begin(); - } - - /*! @copydoc end */ - [[nodiscard]] constexpr sentinel cend() const noexcept { - return end(); - } - -private: - It first; - Sentinel last; -}; - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/memory.hpp b/deps/include/entt/core/memory.hpp deleted file mode 100644 index 58fda45..0000000 --- a/deps/include/entt/core/memory.hpp +++ /dev/null @@ -1,244 +0,0 @@ -#ifndef ENTT_CORE_MEMORY_HPP -#define ENTT_CORE_MEMORY_HPP - -#include -#include -#include -#include -#include -#include "../config/config.h" - -namespace entt { - -/** - * @brief Unwraps fancy pointers, does nothing otherwise (waiting for C++20). - * @tparam Type Pointer type. - * @param ptr Fancy or raw pointer. - * @return A raw pointer that represents the address of the original pointer. - */ -template -[[nodiscard]] constexpr auto to_address(Type &&ptr) noexcept { - if constexpr(std::is_pointer_v>) { - return ptr; - } else { - return to_address(std::forward(ptr).operator->()); - } -} - -/** - * @brief Utility function to design allocation-aware containers. - * @tparam Allocator Type of allocator. - * @param lhs A valid allocator. - * @param rhs Another valid allocator. - */ -template -constexpr void propagate_on_container_copy_assignment([[maybe_unused]] Allocator &lhs, [[maybe_unused]] Allocator &rhs) noexcept { - if constexpr(std::allocator_traits::propagate_on_container_copy_assignment::value) { - lhs = rhs; - } -} - -/** - * @brief Utility function to design allocation-aware containers. - * @tparam Allocator Type of allocator. - * @param lhs A valid allocator. - * @param rhs Another valid allocator. - */ -template -constexpr void propagate_on_container_move_assignment([[maybe_unused]] Allocator &lhs, [[maybe_unused]] Allocator &rhs) noexcept { - if constexpr(std::allocator_traits::propagate_on_container_move_assignment::value) { - lhs = std::move(rhs); - } -} - -/** - * @brief Utility function to design allocation-aware containers. - * @tparam Allocator Type of allocator. - * @param lhs A valid allocator. - * @param rhs Another valid allocator. - */ -template -constexpr void propagate_on_container_swap([[maybe_unused]] Allocator &lhs, [[maybe_unused]] Allocator &rhs) noexcept { - if constexpr(std::allocator_traits::propagate_on_container_swap::value) { - using std::swap; - swap(lhs, rhs); - } else { - ENTT_ASSERT_CONSTEXPR(lhs == rhs, "Cannot swap the containers"); - } -} - -/** - * @brief Deleter for allocator-aware unique pointers (waiting for C++20). - * @tparam Allocator Type of allocator used to manage memory and elements. - */ -template -struct allocation_deleter: private Allocator { - /*! @brief Allocator type. */ - using allocator_type = Allocator; - /*! @brief Pointer type. */ - using pointer = typename std::allocator_traits::pointer; - - /** - * @brief Inherited constructors. - * @param alloc The allocator to use. - */ - constexpr allocation_deleter(const allocator_type &alloc) noexcept(std::is_nothrow_copy_constructible_v) - : Allocator{alloc} {} - - /** - * @brief Destroys the pointed object and deallocates its memory. - * @param ptr A valid pointer to an object of the given type. - */ - constexpr void operator()(pointer ptr) noexcept(std::is_nothrow_destructible_v) { - using alloc_traits = std::allocator_traits; - alloc_traits::destroy(*this, to_address(ptr)); - alloc_traits::deallocate(*this, ptr, 1u); - } -}; - -/** - * @brief Allows `std::unique_ptr` to use allocators (waiting for C++20). - * @tparam Type Type of object to allocate for and to construct. - * @tparam Allocator Type of allocator used to manage memory and elements. - * @tparam Args Types of arguments to use to construct the object. - * @param allocator The allocator to use. - * @param args Parameters to use to construct the object. - * @return A properly initialized unique pointer with a custom deleter. - */ -template -ENTT_CONSTEXPR auto allocate_unique(Allocator &allocator, Args &&...args) { - static_assert(!std::is_array_v, "Array types are not supported"); - - using alloc_traits = typename std::allocator_traits::template rebind_traits; - using allocator_type = typename alloc_traits::allocator_type; - - allocator_type alloc{allocator}; - auto ptr = alloc_traits::allocate(alloc, 1u); - - ENTT_TRY { - alloc_traits::construct(alloc, to_address(ptr), std::forward(args)...); - } - ENTT_CATCH { - alloc_traits::deallocate(alloc, ptr, 1u); - ENTT_THROW; - } - - return std::unique_ptr>{ptr, alloc}; -} - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -template -struct uses_allocator_construction { - template - static constexpr auto args([[maybe_unused]] const Allocator &allocator, Params &&...params) noexcept { - if constexpr(!std::uses_allocator_v && std::is_constructible_v) { - return std::forward_as_tuple(std::forward(params)...); - } else { - static_assert(std::uses_allocator_v, "Ill-formed request"); - - if constexpr(std::is_constructible_v) { - return std::tuple{std::allocator_arg, allocator, std::forward(params)...}; - } else { - static_assert(std::is_constructible_v, "Ill-formed request"); - return std::forward_as_tuple(std::forward(params)..., allocator); - } - } - } -}; - -template -struct uses_allocator_construction> { - using type = std::pair; - - template - static constexpr auto args(const Allocator &allocator, std::piecewise_construct_t, First &&first, Second &&second) noexcept { - return std::make_tuple( - std::piecewise_construct, - std::apply([&allocator](auto &&...curr) { return uses_allocator_construction::args(allocator, std::forward(curr)...); }, std::forward(first)), - std::apply([&allocator](auto &&...curr) { return uses_allocator_construction::args(allocator, std::forward(curr)...); }, std::forward(second))); - } - - template - static constexpr auto args(const Allocator &allocator) noexcept { - return uses_allocator_construction::args(allocator, std::piecewise_construct, std::tuple<>{}, std::tuple<>{}); - } - - template - static constexpr auto args(const Allocator &allocator, First &&first, Second &&second) noexcept { - return uses_allocator_construction::args(allocator, std::piecewise_construct, std::forward_as_tuple(std::forward(first)), std::forward_as_tuple(std::forward(second))); - } - - template - static constexpr auto args(const Allocator &allocator, const std::pair &value) noexcept { - return uses_allocator_construction::args(allocator, std::piecewise_construct, std::forward_as_tuple(value.first), std::forward_as_tuple(value.second)); - } - - template - static constexpr auto args(const Allocator &allocator, std::pair &&value) noexcept { - return uses_allocator_construction::args(allocator, std::piecewise_construct, std::forward_as_tuple(std::move(value.first)), std::forward_as_tuple(std::move(value.second))); - } -}; - -} // namespace internal -/*! @endcond */ - -/** - * @brief Uses-allocator construction utility (waiting for C++20). - * - * Primarily intended for internal use. Prepares the argument list needed to - * create an object of a given type by means of uses-allocator construction. - * - * @tparam Type Type to return arguments for. - * @tparam Allocator Type of allocator used to manage memory and elements. - * @tparam Args Types of arguments to use to construct the object. - * @param allocator The allocator to use. - * @param args Parameters to use to construct the object. - * @return The arguments needed to create an object of the given type. - */ -template -constexpr auto uses_allocator_construction_args(const Allocator &allocator, Args &&...args) noexcept { - return internal::uses_allocator_construction::args(allocator, std::forward(args)...); -} - -/** - * @brief Uses-allocator construction utility (waiting for C++20). - * - * Primarily intended for internal use. Creates an object of a given type by - * means of uses-allocator construction. - * - * @tparam Type Type of object to create. - * @tparam Allocator Type of allocator used to manage memory and elements. - * @tparam Args Types of arguments to use to construct the object. - * @param allocator The allocator to use. - * @param args Parameters to use to construct the object. - * @return A newly created object of the given type. - */ -template -constexpr Type make_obj_using_allocator(const Allocator &allocator, Args &&...args) { - return std::make_from_tuple(internal::uses_allocator_construction::args(allocator, std::forward(args)...)); -} - -/** - * @brief Uses-allocator construction utility (waiting for C++20). - * - * Primarily intended for internal use. Creates an object of a given type by - * means of uses-allocator construction at an uninitialized memory location. - * - * @tparam Type Type of object to create. - * @tparam Allocator Type of allocator used to manage memory and elements. - * @tparam Args Types of arguments to use to construct the object. - * @param value Memory location in which to place the object. - * @param allocator The allocator to use. - * @param args Parameters to use to construct the object. - * @return A pointer to the newly created object of the given type. - */ -template -constexpr Type *uninitialized_construct_using_allocator(Type *value, const Allocator &allocator, Args &&...args) { - return std::apply([value](auto &&...curr) { return ::new(value) Type(std::forward(curr)...); }, internal::uses_allocator_construction::args(allocator, std::forward(args)...)); -} - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/monostate.hpp b/deps/include/entt/core/monostate.hpp deleted file mode 100644 index 57f5f41..0000000 --- a/deps/include/entt/core/monostate.hpp +++ /dev/null @@ -1,60 +0,0 @@ -#ifndef ENTT_CORE_MONOSTATE_HPP -#define ENTT_CORE_MONOSTATE_HPP - -#include "../config/config.h" -#include "fwd.hpp" - -namespace entt { - -/** - * @brief Minimal implementation of the monostate pattern. - * - * A minimal, yet complete configuration system built on top of the monostate - * pattern. Thread safe by design, it works only with basic types like `int`s or - * `bool`s.
- * Multiple types and therefore more than one value can be associated with a - * single key. Because of this, users must pay attention to use the same type - * both during an assignment and when they try to read back their data. - * Otherwise, they can incur in unexpected results. - */ -template -struct monostate { - /** - * @brief Assigns a value of a specific type to a given key. - * @tparam Type Type of the value to assign. - * @param val User data to assign to the given key. - * @return This monostate object. - */ - template - monostate &operator=(Type val) noexcept { - value = val; - return *this; - } - - /** - * @brief Gets a value of a specific type for a given key. - * @tparam Type Type of the value to get. - * @return Stored value, if any. - */ - template - operator Type() const noexcept { - return value; - } - -private: - template - // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) - inline static ENTT_MAYBE_ATOMIC(Type) value{}; -}; - -/** - * @brief Helper variable template. - * @tparam Value Value used to differentiate between different variables. - */ -template -// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables) -inline monostate monostate_v{}; - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/ranges.hpp b/deps/include/entt/core/ranges.hpp deleted file mode 100644 index 430229f..0000000 --- a/deps/include/entt/core/ranges.hpp +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef ENTT_CORE_RANGES_HPP -#define ENTT_CORE_RANGES_HPP - -#if __has_include() -# include -# -# if defined(__cpp_lib_ranges) -# include -# include "iterator.hpp" - -template -inline constexpr bool std::ranges::enable_borrowed_range>{true}; - -template -inline constexpr bool std::ranges::enable_view>{true}; - -# endif -#endif - -#endif \ No newline at end of file diff --git a/deps/include/entt/core/tuple.hpp b/deps/include/entt/core/tuple.hpp deleted file mode 100644 index a64c51c..0000000 --- a/deps/include/entt/core/tuple.hpp +++ /dev/null @@ -1,95 +0,0 @@ -#ifndef ENTT_CORE_TUPLE_HPP -#define ENTT_CORE_TUPLE_HPP - -#include -#include -#include - -namespace entt { - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -template -struct is_tuple_impl: std::false_type {}; - -template -struct is_tuple_impl>: std::true_type {}; - -} // namespace internal -/*! @endcond */ - -/** - * @brief Provides the member constant `value` to true if a given type is a - * tuple, false otherwise. - * @tparam Type The type to test. - */ -template -struct is_tuple: internal::is_tuple_impl> {}; - -/** - * @brief Helper variable template. - * @tparam Type The type to test. - */ -template -inline constexpr bool is_tuple_v = is_tuple::value; - -/** - * @brief Utility function to unwrap tuples of a single element. - * @tparam Type Tuple type of any sizes. - * @param value A tuple object of the given type. - * @return The tuple itself if it contains more than one element, the first - * element otherwise. - */ -template -constexpr decltype(auto) unwrap_tuple(Type &&value) noexcept { - if constexpr(std::tuple_size_v> == 1u) { - return std::get<0>(std::forward(value)); - } else { - return std::forward(value); - } -} - -/** - * @brief Utility class to forward-and-apply tuple objects. - * @tparam Func Type of underlying invocable object. - */ -template -struct forward_apply: private Func { - /** - * @brief Constructs a forward-and-apply object. - * @tparam Args Types of arguments to use to construct the new instance. - * @param args Parameters to use to construct the instance. - */ - template - constexpr forward_apply(Args &&...args) noexcept(std::is_nothrow_constructible_v) - : Func{std::forward(args)...} {} - - /** - * @brief Forwards and applies the arguments with the underlying function. - * @tparam Type Tuple-like type to forward to the underlying function. - * @param args Parameters to forward to the underlying function. - * @return Return value of the underlying function, if any. - */ - template - constexpr decltype(auto) operator()(Type &&args) noexcept(noexcept(std::apply(std::declval(), args))) { - return std::apply(static_cast(*this), std::forward(args)); - } - - /*! @copydoc operator()() */ - template - constexpr decltype(auto) operator()(Type &&args) const noexcept(noexcept(std::apply(std::declval(), args))) { - return std::apply(static_cast(*this), std::forward(args)); - } -}; - -/** - * @brief Deduction guide. - * @tparam Func Type of underlying invocable object. - */ -template -forward_apply(Func) -> forward_apply>>; - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/type_info.hpp b/deps/include/entt/core/type_info.hpp deleted file mode 100644 index e03a8e1..0000000 --- a/deps/include/entt/core/type_info.hpp +++ /dev/null @@ -1,268 +0,0 @@ -#ifndef ENTT_CORE_TYPE_INFO_HPP -#define ENTT_CORE_TYPE_INFO_HPP - -#include -#include -#include -#include "../config/config.h" -#include "../core/attribute.h" -#include "fwd.hpp" -#include "hashed_string.hpp" - -namespace entt { - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -struct ENTT_API type_index final { - [[nodiscard]] static id_type next() noexcept { - static ENTT_MAYBE_ATOMIC(id_type) value{}; - return value++; - } -}; - -template -[[nodiscard]] constexpr auto stripped_type_name() noexcept { -#if defined ENTT_PRETTY_FUNCTION - std::string_view pretty_function{static_cast(ENTT_PRETTY_FUNCTION)}; - auto first = pretty_function.find_first_not_of(' ', pretty_function.find_first_of(ENTT_PRETTY_FUNCTION_PREFIX) + 1); - auto value = pretty_function.substr(first, pretty_function.find_last_of(ENTT_PRETTY_FUNCTION_SUFFIX) - first); - return value; -#else - return std::string_view{""}; -#endif -} - -template().find_first_of('.')> -[[nodiscard]] constexpr std::string_view type_name(int) noexcept { - constexpr auto value = stripped_type_name(); - return value; -} - -template -[[nodiscard]] std::string_view type_name(char) noexcept { - static const auto value = stripped_type_name(); - return value; -} - -template().find_first_of('.')> -[[nodiscard]] constexpr id_type type_hash(int) noexcept { - constexpr auto stripped = stripped_type_name(); - constexpr auto value = hashed_string::value(stripped.data(), stripped.size()); - return value; -} - -template -[[nodiscard]] id_type type_hash(char) noexcept { - static const auto value = [](const auto stripped) { - return hashed_string::value(stripped.data(), stripped.size()); - }(stripped_type_name()); - return value; -} - -} // namespace internal -/*! @endcond */ - -/** - * @brief Type sequential identifier. - * @tparam Type Type for which to generate a sequential identifier. - */ -template -struct ENTT_API type_index final { - /** - * @brief Returns the sequential identifier of a given type. - * @return The sequential identifier of a given type. - */ - [[nodiscard]] static id_type value() noexcept { - static const id_type value = internal::type_index::next(); - return value; - } - - /*! @copydoc value */ - [[nodiscard]] constexpr operator id_type() const noexcept { - return value(); - } -}; - -/** - * @brief Type hash. - * @tparam Type Type for which to generate a hash value. - */ -template -struct type_hash final { - /** - * @brief Returns the numeric representation of a given type. - * @return The numeric representation of the given type. - */ -#if defined ENTT_PRETTY_FUNCTION - [[nodiscard]] static constexpr id_type value() noexcept { - return internal::type_hash(0); -#else - [[nodiscard]] static constexpr id_type value() noexcept { - return type_index::value(); -#endif - } - - /*! @copydoc value */ - [[nodiscard]] constexpr operator id_type() const noexcept { - return value(); - } -}; - -/** - * @brief Type name. - * @tparam Type Type for which to generate a name. - */ -template -struct type_name final { - /** - * @brief Returns the name of a given type. - * @return The name of the given type. - */ - [[nodiscard]] static constexpr std::string_view value() noexcept { - return internal::type_name(0); - } - - /*! @copydoc value */ - [[nodiscard]] constexpr operator std::string_view() const noexcept { - return value(); - } -}; - -/*! @brief Implementation specific information about a type. */ -struct type_info final { - /** - * @brief Constructs a type info object for a given type. - * @tparam Type Type for which to construct a type info object. - */ - template - // NOLINTBEGIN(modernize-use-transparent-functors) - constexpr type_info(std::in_place_type_t) noexcept - : seq{type_index>>::value()}, - identifier{type_hash>>::value()}, - alias{type_name>>::value()} {} - // NOLINTEND(modernize-use-transparent-functors) - - /** - * @brief Type index. - * @return Type index. - */ - [[nodiscard]] constexpr id_type index() const noexcept { - return seq; - } - - /** - * @brief Type hash. - * @return Type hash. - */ - [[nodiscard]] constexpr id_type hash() const noexcept { - return identifier; - } - - /** - * @brief Type name. - * @return Type name. - */ - [[nodiscard]] constexpr std::string_view name() const noexcept { - return alias; - } - -private: - id_type seq; - id_type identifier; - std::string_view alias; -}; - -/** - * @brief Compares the contents of two type info objects. - * @param lhs A type info object. - * @param rhs A type info object. - * @return True if the two type info objects are identical, false otherwise. - */ -[[nodiscard]] inline constexpr bool operator==(const type_info &lhs, const type_info &rhs) noexcept { - return lhs.hash() == rhs.hash(); -} - -/** - * @brief Compares the contents of two type info objects. - * @param lhs A type info object. - * @param rhs A type info object. - * @return True if the two type info objects differ, false otherwise. - */ -[[nodiscard]] inline constexpr bool operator!=(const type_info &lhs, const type_info &rhs) noexcept { - return !(lhs == rhs); -} - -/** - * @brief Compares two type info objects. - * @param lhs A valid type info object. - * @param rhs A valid type info object. - * @return True if the first element is less than the second, false otherwise. - */ -[[nodiscard]] inline constexpr bool operator<(const type_info &lhs, const type_info &rhs) noexcept { - return lhs.index() < rhs.index(); -} - -/** - * @brief Compares two type info objects. - * @param lhs A valid type info object. - * @param rhs A valid type info object. - * @return True if the first element is less than or equal to the second, false - * otherwise. - */ -[[nodiscard]] inline constexpr bool operator<=(const type_info &lhs, const type_info &rhs) noexcept { - return !(rhs < lhs); -} - -/** - * @brief Compares two type info objects. - * @param lhs A valid type info object. - * @param rhs A valid type info object. - * @return True if the first element is greater than the second, false - * otherwise. - */ -[[nodiscard]] inline constexpr bool operator>(const type_info &lhs, const type_info &rhs) noexcept { - return rhs < lhs; -} - -/** - * @brief Compares two type info objects. - * @param lhs A valid type info object. - * @param rhs A valid type info object. - * @return True if the first element is greater than or equal to the second, - * false otherwise. - */ -[[nodiscard]] inline constexpr bool operator>=(const type_info &lhs, const type_info &rhs) noexcept { - return !(lhs < rhs); -} - -/** - * @brief Returns the type info object associated to a given type. - * - * The returned element refers to an object with static storage duration.
- * The type doesn't need to be a complete type. If the type is a reference, the - * result refers to the referenced type. In all cases, top-level cv-qualifiers - * are ignored. - * - * @tparam Type Type for which to generate a type info object. - * @return A reference to a properly initialized type info object. - */ -template -[[nodiscard]] const type_info &type_id() noexcept { - if constexpr(std::is_same_v>>) { - static type_info instance{std::in_place_type}; - return instance; - } else { - return type_id>>(); - } -} - -/*! @copydoc type_id */ -template -[[nodiscard]] const type_info &type_id(Type &&) noexcept { - return type_id>>(); -} - -} // namespace entt - -#endif diff --git a/deps/include/entt/core/type_traits.hpp b/deps/include/entt/core/type_traits.hpp deleted file mode 100644 index 16b4dad..0000000 --- a/deps/include/entt/core/type_traits.hpp +++ /dev/null @@ -1,919 +0,0 @@ -#ifndef ENTT_CORE_TYPE_TRAITS_HPP -#define ENTT_CORE_TYPE_TRAITS_HPP - -#include -#include -#include -#include -#include -#include "../config/config.h" -#include "fwd.hpp" - -namespace entt { - -/** - * @brief Utility class to disambiguate overloaded functions. - * @tparam N Number of choices available. - */ -template -struct choice_t - // unfortunately, doxygen cannot parse such a construct - : /*! @cond TURN_OFF_DOXYGEN */ choice_t /*! @endcond */ -{}; - -/*! @copybrief choice_t */ -template<> -struct choice_t<0> {}; - -/** - * @brief Variable template for the choice trick. - * @tparam N Number of choices available. - */ -template -inline constexpr choice_t choice{}; - -/** - * @brief Identity type trait. - * - * Useful to establish non-deduced contexts in template argument deduction - * (waiting for C++20) or to provide types through function arguments. - * - * @tparam Type A type. - */ -template -struct type_identity { - /*! @brief Identity type. */ - using type = Type; -}; - -/** - * @brief Helper type. - * @tparam Type A type. - */ -template -using type_identity_t = typename type_identity::type; - -/** - * @brief A type-only `sizeof` wrapper that returns 0 where `sizeof` complains. - * @tparam Type The type of which to return the size. - */ -template -struct size_of: std::integral_constant {}; - -/*! @copydoc size_of */ -template -struct size_of> - : std::integral_constant {}; - -/** - * @brief Helper variable template. - * @tparam Type The type of which to return the size. - */ -template -inline constexpr std::size_t size_of_v = size_of::value; - -/** - * @brief Using declaration to be used to _repeat_ the same type a number of - * times equal to the size of a given parameter pack. - * @tparam Type A type to repeat. - */ -template -using unpack_as_type = Type; - -/** - * @brief Helper variable template to be used to _repeat_ the same value a - * number of times equal to the size of a given parameter pack. - * @tparam Value A value to repeat. - */ -template -inline constexpr auto unpack_as_value = Value; - -/** - * @brief Wraps a static constant. - * @tparam Value A static constant. - */ -template -using integral_constant = std::integral_constant; - -/** - * @brief Alias template to facilitate the creation of named values. - * @tparam Value A constant value at least convertible to `id_type`. - */ -template -using tag = integral_constant; - -/** - * @brief A class to use to push around lists of types, nothing more. - * @tparam Type Types provided by the type list. - */ -template -struct type_list { - /*! @brief Type list type. */ - using type = type_list; - /*! @brief Compile-time number of elements in the type list. */ - static constexpr auto size = sizeof...(Type); -}; - -/*! @brief Primary template isn't defined on purpose. */ -template -struct type_list_element; - -/** - * @brief Provides compile-time indexed access to the types of a type list. - * @tparam Index Index of the type to return. - * @tparam First First type provided by the type list. - * @tparam Other Other types provided by the type list. - */ -template -struct type_list_element> - : type_list_element> {}; - -/** - * @brief Provides compile-time indexed access to the types of a type list. - * @tparam First First type provided by the type list. - * @tparam Other Other types provided by the type list. - */ -template -struct type_list_element<0u, type_list> { - /*! @brief Searched type. */ - using type = First; -}; - -/** - * @brief Helper type. - * @tparam Index Index of the type to return. - * @tparam List Type list to search into. - */ -template -using type_list_element_t = typename type_list_element::type; - -/*! @brief Primary template isn't defined on purpose. */ -template -struct type_list_index; - -/** - * @brief Provides compile-time type access to the types of a type list. - * @tparam Type Type to look for and for which to return the index. - * @tparam First First type provided by the type list. - * @tparam Other Other types provided by the type list. - */ -template -struct type_list_index> { - /*! @brief Unsigned integer type. */ - using value_type = std::size_t; - /*! @brief Compile-time position of the given type in the sublist. */ - static constexpr value_type value = 1u + type_list_index>::value; -}; - -/** - * @brief Provides compile-time type access to the types of a type list. - * @tparam Type Type to look for and for which to return the index. - * @tparam Other Other types provided by the type list. - */ -template -struct type_list_index> { - static_assert(type_list_index>::value == sizeof...(Other), "Non-unique type"); - /*! @brief Unsigned integer type. */ - using value_type = std::size_t; - /*! @brief Compile-time position of the given type in the sublist. */ - static constexpr value_type value = 0u; -}; - -/** - * @brief Provides compile-time type access to the types of a type list. - * @tparam Type Type to look for and for which to return the index. - */ -template -struct type_list_index> { - /*! @brief Unsigned integer type. */ - using value_type = std::size_t; - /*! @brief Compile-time position of the given type in the sublist. */ - static constexpr value_type value = 0u; -}; - -/** - * @brief Helper variable template. - * @tparam List Type list. - * @tparam Type Type to look for and for which to return the index. - */ -template -inline constexpr std::size_t type_list_index_v = type_list_index::value; - -/** - * @brief Concatenates multiple type lists. - * @tparam Type Types provided by the first type list. - * @tparam Other Types provided by the second type list. - * @return A type list composed by the types of both the type lists. - */ -template -constexpr type_list operator+(type_list, type_list) { - return {}; -} - -/*! @brief Primary template isn't defined on purpose. */ -template -struct type_list_cat; - -/*! @brief Concatenates multiple type lists. */ -template<> -struct type_list_cat<> { - /*! @brief A type list composed by the types of all the type lists. */ - using type = type_list<>; -}; - -/** - * @brief Concatenates multiple type lists. - * @tparam Type Types provided by the first type list. - * @tparam Other Types provided by the second type list. - * @tparam List Other type lists, if any. - */ -template -struct type_list_cat, type_list, List...> { - /*! @brief A type list composed by the types of all the type lists. */ - using type = typename type_list_cat, List...>::type; -}; - -/** - * @brief Concatenates multiple type lists. - * @tparam Type Types provided by the type list. - */ -template -struct type_list_cat> { - /*! @brief A type list composed by the types of all the type lists. */ - using type = type_list; -}; - -/** - * @brief Helper type. - * @tparam List Type lists to concatenate. - */ -template -using type_list_cat_t = typename type_list_cat::type; - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -template -struct type_list_unique; - -template -struct type_list_unique, Type...> - : std::conditional_t<(std::is_same_v || ...), type_list_unique, Type...>, type_list_unique, Type..., First>> {}; - -template -struct type_list_unique, Type...> { - using type = type_list; -}; - -} // namespace internal -/*! @endcond */ - -/** - * @brief Removes duplicates types from a type list. - * @tparam List Type list. - */ -template -struct type_list_unique { - /*! @brief A type list without duplicate types. */ - using type = typename internal::type_list_unique::type; -}; - -/** - * @brief Helper type. - * @tparam List Type list. - */ -template -using type_list_unique_t = typename type_list_unique::type; - -/** - * @brief Provides the member constant `value` to true if a type list contains a - * given type, false otherwise. - * @tparam List Type list. - * @tparam Type Type to look for. - */ -template -struct type_list_contains; - -/** - * @copybrief type_list_contains - * @tparam Type Types provided by the type list. - * @tparam Other Type to look for. - */ -template -struct type_list_contains, Other> - : std::bool_constant<(std::is_same_v || ...)> {}; - -/** - * @brief Helper variable template. - * @tparam List Type list. - * @tparam Type Type to look for. - */ -template -inline constexpr bool type_list_contains_v = type_list_contains::value; - -/*! @brief Primary template isn't defined on purpose. */ -template -struct type_list_diff; - -/** - * @brief Computes the difference between two type lists. - * @tparam Type Types provided by the first type list. - * @tparam Other Types provided by the second type list. - */ -template -struct type_list_diff, type_list> { - /*! @brief A type list that is the difference between the two type lists. */ - using type = type_list_cat_t, Type>, type_list<>, type_list>...>; -}; - -/** - * @brief Helper type. - * @tparam List Type lists between which to compute the difference. - */ -template -using type_list_diff_t = typename type_list_diff::type; - -/*! @brief Primary template isn't defined on purpose. */ -template class> -struct type_list_transform; - -/** - * @brief Applies a given _function_ to a type list and generate a new list. - * @tparam Type Types provided by the type list. - * @tparam Op Unary operation as template class with a type member named `type`. - */ -template class Op> -struct type_list_transform, Op> { - /*! @brief Resulting type list after applying the transform function. */ - using type = type_list::type...>; -}; - -/** - * @brief Helper type. - * @tparam List Type list. - * @tparam Op Unary operation as template class with a type member named `type`. - */ -template class Op> -using type_list_transform_t = typename type_list_transform::type; - -/** - * @brief A class to use to push around lists of constant values, nothing more. - * @tparam Value Values provided by the value list. - */ -template -struct value_list { - /*! @brief Value list type. */ - using type = value_list; - /*! @brief Compile-time number of elements in the value list. */ - static constexpr auto size = sizeof...(Value); -}; - -/*! @brief Primary template isn't defined on purpose. */ -template -struct value_list_element; - -/** - * @brief Provides compile-time indexed access to the values of a value list. - * @tparam Index Index of the value to return. - * @tparam Value First value provided by the value list. - * @tparam Other Other values provided by the value list. - */ -template -struct value_list_element> - : value_list_element> {}; - -/** - * @brief Provides compile-time indexed access to the types of a type list. - * @tparam Value First value provided by the value list. - * @tparam Other Other values provided by the value list. - */ -template -struct value_list_element<0u, value_list> { - /*! @brief Searched type. */ - using type = decltype(Value); - /*! @brief Searched value. */ - static constexpr auto value = Value; -}; - -/** - * @brief Helper type. - * @tparam Index Index of the type to return. - * @tparam List Value list to search into. - */ -template -using value_list_element_t = typename value_list_element::type; - -/** - * @brief Helper type. - * @tparam Index Index of the value to return. - * @tparam List Value list to search into. - */ -template -inline constexpr auto value_list_element_v = value_list_element::value; - -/*! @brief Primary template isn't defined on purpose. */ -template -struct value_list_index; - -/** - * @brief Provides compile-time type access to the values of a value list. - * @tparam Value Value to look for and for which to return the index. - * @tparam First First value provided by the value list. - * @tparam Other Other values provided by the value list. - */ -template -struct value_list_index> { - /*! @brief Unsigned integer type. */ - using value_type = std::size_t; - /*! @brief Compile-time position of the given value in the sublist. */ - static constexpr value_type value = 1u + value_list_index>::value; -}; - -/** - * @brief Provides compile-time type access to the values of a value list. - * @tparam Value Value to look for and for which to return the index. - * @tparam Other Other values provided by the value list. - */ -template -struct value_list_index> { - static_assert(value_list_index>::value == sizeof...(Other), "Non-unique type"); - /*! @brief Unsigned integer type. */ - using value_type = std::size_t; - /*! @brief Compile-time position of the given value in the sublist. */ - static constexpr value_type value = 0u; -}; - -/** - * @brief Provides compile-time type access to the values of a value list. - * @tparam Value Value to look for and for which to return the index. - */ -template -struct value_list_index> { - /*! @brief Unsigned integer type. */ - using value_type = std::size_t; - /*! @brief Compile-time position of the given type in the sublist. */ - static constexpr value_type value = 0u; -}; - -/** - * @brief Helper variable template. - * @tparam List Value list. - * @tparam Value Value to look for and for which to return the index. - */ -template -inline constexpr std::size_t value_list_index_v = value_list_index::value; - -/** - * @brief Concatenates multiple value lists. - * @tparam Value Values provided by the first value list. - * @tparam Other Values provided by the second value list. - * @return A value list composed by the values of both the value lists. - */ -template -constexpr value_list operator+(value_list, value_list) { - return {}; -} - -/*! @brief Primary template isn't defined on purpose. */ -template -struct value_list_cat; - -/*! @brief Concatenates multiple value lists. */ -template<> -struct value_list_cat<> { - /*! @brief A value list composed by the values of all the value lists. */ - using type = value_list<>; -}; - -/** - * @brief Concatenates multiple value lists. - * @tparam Value Values provided by the first value list. - * @tparam Other Values provided by the second value list. - * @tparam List Other value lists, if any. - */ -template -struct value_list_cat, value_list, List...> { - /*! @brief A value list composed by the values of all the value lists. */ - using type = typename value_list_cat, List...>::type; -}; - -/** - * @brief Concatenates multiple value lists. - * @tparam Value Values provided by the value list. - */ -template -struct value_list_cat> { - /*! @brief A value list composed by the values of all the value lists. */ - using type = value_list; -}; - -/** - * @brief Helper type. - * @tparam List Value lists to concatenate. - */ -template -using value_list_cat_t = typename value_list_cat::type; - -/*! @brief Primary template isn't defined on purpose. */ -template -struct value_list_unique; - -/** - * @brief Removes duplicates values from a value list. - * @tparam Value One of the values provided by the given value list. - * @tparam Other The other values provided by the given value list. - */ -template -struct value_list_unique> { - /*! @brief A value list without duplicate types. */ - using type = std::conditional_t< - ((Value == Other) || ...), - typename value_list_unique>::type, - value_list_cat_t, typename value_list_unique>::type>>; -}; - -/*! @brief Removes duplicates values from a value list. */ -template<> -struct value_list_unique> { - /*! @brief A value list without duplicate types. */ - using type = value_list<>; -}; - -/** - * @brief Helper type. - * @tparam Type A value list. - */ -template -using value_list_unique_t = typename value_list_unique::type; - -/** - * @brief Provides the member constant `value` to true if a value list contains - * a given value, false otherwise. - * @tparam List Value list. - * @tparam Value Value to look for. - */ -template -struct value_list_contains; - -/** - * @copybrief value_list_contains - * @tparam Value Values provided by the value list. - * @tparam Other Value to look for. - */ -template -struct value_list_contains, Other> - : std::bool_constant<((Value == Other) || ...)> {}; - -/** - * @brief Helper variable template. - * @tparam List Value list. - * @tparam Value Value to look for. - */ -template -inline constexpr bool value_list_contains_v = value_list_contains::value; - -/*! @brief Primary template isn't defined on purpose. */ -template -struct value_list_diff; - -/** - * @brief Computes the difference between two value lists. - * @tparam Value Values provided by the first value list. - * @tparam Other Values provided by the second value list. - */ -template -struct value_list_diff, value_list> { - /*! @brief A value list that is the difference between the two value lists. */ - using type = value_list_cat_t, Value>, value_list<>, value_list>...>; -}; - -/** - * @brief Helper type. - * @tparam List Value lists between which to compute the difference. - */ -template -using value_list_diff_t = typename value_list_diff::type; - -/*! @brief Same as std::is_invocable, but with tuples. */ -template -struct is_applicable: std::false_type {}; - -/** - * @copybrief is_applicable - * @tparam Func A valid function type. - * @tparam Tuple Tuple-like type. - * @tparam Args The list of arguments to use to probe the function type. - */ -template class Tuple, typename... Args> -struct is_applicable>: std::is_invocable {}; - -/** - * @copybrief is_applicable - * @tparam Func A valid function type. - * @tparam Tuple Tuple-like type. - * @tparam Args The list of arguments to use to probe the function type. - */ -template class Tuple, typename... Args> -struct is_applicable>: std::is_invocable {}; - -/** - * @brief Helper variable template. - * @tparam Func A valid function type. - * @tparam Args The list of arguments to use to probe the function type. - */ -template -inline constexpr bool is_applicable_v = is_applicable::value; - -/*! @brief Same as std::is_invocable_r, but with tuples for arguments. */ -template -struct is_applicable_r: std::false_type {}; - -/** - * @copybrief is_applicable_r - * @tparam Ret The type to which the return type of the function should be - * convertible. - * @tparam Func A valid function type. - * @tparam Args The list of arguments to use to probe the function type. - */ -template -struct is_applicable_r>: std::is_invocable_r {}; - -/** - * @brief Helper variable template. - * @tparam Ret The type to which the return type of the function should be - * convertible. - * @tparam Func A valid function type. - * @tparam Args The list of arguments to use to probe the function type. - */ -template -inline constexpr bool is_applicable_r_v = is_applicable_r::value; - -/** - * @brief Provides the member constant `value` to true if a given type is - * complete, false otherwise. - * @tparam Type The type to test. - */ -template -struct is_complete: std::false_type {}; - -/*! @copydoc is_complete */ -template -struct is_complete>: std::true_type {}; - -/** - * @brief Helper variable template. - * @tparam Type The type to test. - */ -template -inline constexpr bool is_complete_v = is_complete::value; - -/** - * @brief Provides the member constant `value` to true if a given type is an - * iterator, false otherwise. - * @tparam Type The type to test. - */ -template -struct is_iterator: std::false_type {}; - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -template -struct has_iterator_category: std::false_type {}; - -template -struct has_iterator_category::iterator_category>>: std::true_type {}; - -} // namespace internal -/*! @endcond */ - -/*! @copydoc is_iterator */ -template -struct is_iterator>>>> - : internal::has_iterator_category {}; - -/** - * @brief Helper variable template. - * @tparam Type The type to test. - */ -template -inline constexpr bool is_iterator_v = is_iterator::value; - -/** - * @brief Provides the member constant `value` to true if a given type is both - * an empty and non-final class, false otherwise. - * @tparam Type The type to test - */ -template -struct is_ebco_eligible - : std::bool_constant && !std::is_final_v> {}; - -/** - * @brief Helper variable template. - * @tparam Type The type to test. - */ -template -inline constexpr bool is_ebco_eligible_v = is_ebco_eligible::value; - -/** - * @brief Provides the member constant `value` to true if `Type::is_transparent` - * is valid and denotes a type, false otherwise. - * @tparam Type The type to test. - */ -template -struct is_transparent: std::false_type {}; - -/*! @copydoc is_transparent */ -template -struct is_transparent>: std::true_type {}; - -/** - * @brief Helper variable template. - * @tparam Type The type to test. - */ -template -inline constexpr bool is_transparent_v = is_transparent::value; - -/*! @cond TURN_OFF_DOXYGEN */ -namespace internal { - -template -struct has_tuple_size_value: std::false_type {}; - -template -struct has_tuple_size_value::value)>>: std::true_type {}; - -template -struct has_value_type: std::false_type {}; - -template -struct has_value_type>: std::true_type {}; - -template -[[nodiscard]] constexpr bool dispatch_is_equality_comparable(); - -template -[[nodiscard]] constexpr bool unpack_maybe_equality_comparable(std::index_sequence) { - return (dispatch_is_equality_comparable>() && ...); -} - -template -[[nodiscard]] constexpr bool maybe_equality_comparable(char) { - return false; -} - -template -[[nodiscard]] constexpr auto maybe_equality_comparable(int) -> decltype(std::declval() == std::declval()) { - return true; -} - -template -[[nodiscard]] constexpr bool dispatch_is_equality_comparable() { - // NOLINTBEGIN(modernize-use-transparent-functors) - if constexpr(std::is_array_v) { - return false; - } else if constexpr(!is_iterator_v && has_value_type::value) { - if constexpr(std::is_same_v || dispatch_is_equality_comparable()) { - return maybe_equality_comparable(0); - } else { - return false; - } - } else if constexpr(is_complete_v>>) { - if constexpr(has_tuple_size_value::value) { - return maybe_equality_comparable(0) && unpack_maybe_equality_comparable(std::make_index_sequence::value>{}); - } else { - return maybe_equality_comparable(0); - } - } else { - return maybe_equality_comparable(0); - } - // NOLINTEND(modernize-use-transparent-functors) -} - -} // namespace internal -/*! @endcond */ - -/** - * @brief Provides the member constant `value` to true if a given type is - * equality comparable, false otherwise. - * @tparam Type The type to test. - */ -template -struct is_equality_comparable: std::bool_constant()> {}; - -/*! @copydoc is_equality_comparable */ -template -struct is_equality_comparable: is_equality_comparable {}; - -/** - * @brief Helper variable template. - * @tparam Type The type to test. - */ -template -inline constexpr bool is_equality_comparable_v = is_equality_comparable::value; - -/** - * @brief Transcribes the constness of a type to another type. - * @tparam To The type to which to transcribe the constness. - * @tparam From The type from which to transcribe the constness. - */ -template -struct constness_as { - /*! @brief The type resulting from the transcription of the constness. */ - using type = std::remove_const_t; -}; - -/*! @copydoc constness_as */ -template -struct constness_as { - /*! @brief The type resulting from the transcription of the constness. */ - using type = const To; -}; - -/** - * @brief Alias template to facilitate the transcription of the constness. - * @tparam To The type to which to transcribe the constness. - * @tparam From The type from which to transcribe the constness. - */ -template -using constness_as_t = typename constness_as::type; - -/** - * @brief Extracts the class of a non-static member object or function. - * @tparam Member A pointer to a non-static member object or function. - */ -template -class member_class { - static_assert(std::is_member_pointer_v, "Invalid pointer type to non-static member object or function"); - - template - static Class *clazz(Ret (Class::*)(Args...)); - - template - static Class *clazz(Ret (Class::*)(Args...) const); - - template - static Class *clazz(Type Class::*); - -public: - /*! @brief The class of the given non-static member object or function. */ - using type = std::remove_pointer_t()))>; -}; - -/** - * @brief Helper type. - * @tparam Member A pointer to a non-static member object or function. - */ -template -using member_class_t = typename member_class::type; - -/** - * @brief Extracts the n-th argument of a _callable_ type. - * @tparam Index The index of the argument to extract. - * @tparam Candidate A valid _callable_ type. - */ -template -class nth_argument { - template - static constexpr type_list pick_up(Ret (*)(Args...)); - - template - static constexpr type_list pick_up(Ret (Class ::*)(Args...)); - - template - static constexpr type_list pick_up(Ret (Class ::*)(Args...) const); - - template - static constexpr type_list pick_up(Type Class ::*); - - template - static constexpr decltype(pick_up(&Type::operator())) pick_up(Type &&); - -public: - /*! @brief N-th argument of the _callable_ type. */ - using type = type_list_element_t()))>; -}; - -/** - * @brief Helper type. - * @tparam Index The index of the argument to extract. - * @tparam Candidate A valid function, member function or data member type. - */ -template -using nth_argument_t = typename nth_argument::type; - -} // namespace entt - -template -struct std::tuple_size>: std::integral_constant::size> {}; - -template -struct std::tuple_element>: entt::type_list_element> {}; - -template -struct std::tuple_size>: std::integral_constant::size> {}; - -template -struct std::tuple_element>: entt::value_list_element> {}; - -#endif diff --git a/deps/include/entt/core/utility.hpp b/deps/include/entt/core/utility.hpp deleted file mode 100644 index ddab926..0000000 --- a/deps/include/entt/core/utility.hpp +++ /dev/null @@ -1,101 +0,0 @@ -#ifndef ENTT_CORE_UTILITY_HPP -#define ENTT_CORE_UTILITY_HPP - -#include -#include - -namespace entt { - -/*! @brief Identity function object (waiting for C++20). */ -struct identity { - /*! @brief Indicates that this is a transparent function object. */ - using is_transparent = void; - - /** - * @brief Returns its argument unchanged. - * @tparam Type Type of the argument. - * @param value The actual argument. - * @return The submitted value as-is. - */ - template - [[nodiscard]] constexpr Type &&operator()(Type &&value) const noexcept { - return std::forward(value); - } -}; - -/** - * @brief Constant utility to disambiguate overloaded members of a class. - * @tparam Type Type of the desired overload. - * @tparam Class Type of class to which the member belongs. - * @param member A valid pointer to a member. - * @return Pointer to the member. - */ -template -[[nodiscard]] constexpr auto overload(Type Class::*member) noexcept { - return member; -} - -/** - * @brief Constant utility to disambiguate overloaded functions. - * @tparam Func Function type of the desired overload. - * @param func A valid pointer to a function. - * @return Pointer to the function. - */ -template -[[nodiscard]] constexpr auto overload(Func *func) noexcept { - return func; -} - -/** - * @brief Helper type for visitors. - * @tparam Func Types of function objects. - */ -template -struct overloaded: Func... { - using Func::operator()...; -}; - -/** - * @brief Deduction guide. - * @tparam Func Types of function objects. - */ -template -overloaded(Func...) -> overloaded; - -/** - * @brief Basic implementation of a y-combinator. - * @tparam Func Type of a potentially recursive function. - */ -template -struct y_combinator { - /** - * @brief Constructs a y-combinator from a given function. - * @param recursive A potentially recursive function. - */ - constexpr y_combinator(Func recursive) noexcept(std::is_nothrow_move_constructible_v) - : func{std::move(recursive)} {} - - /** - * @brief Invokes a y-combinator and therefore its underlying function. - * @tparam Args Types of arguments to use to invoke the underlying function. - * @param args Parameters to use to invoke the underlying function. - * @return Return value of the underlying function, if any. - */ - template - constexpr decltype(auto) operator()(Args &&...args) const noexcept(std::is_nothrow_invocable_v) { - return func(*this, std::forward(args)...); - } - - /*! @copydoc operator()() */ - template - constexpr decltype(auto) operator()(Args &&...args) noexcept(std::is_nothrow_invocable_v) { - return func(*this, std::forward(args)...); - } - -private: - Func func; -}; - -} // namespace entt - -#endif -- cgit