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/memory.hpp | 244 -------------------------------------- 1 file changed, 244 deletions(-) delete mode 100644 deps/include/entt/core/memory.hpp (limited to 'deps/include/entt/core/memory.hpp') 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 -- cgit