entt: there is a reason why an allocator concept does not exist...

Author: skypjack

src/entt/container/dense_map.hpp

@@ -17,7 +17,6 @@
 #include "../config/config.h"
 #include "../core/bit.hpp"
 #include "../core/compressed_pair.hpp"
-#include "../core/concepts.hpp"
 #include "../core/iterator.hpp"
 #include "../core/memory.hpp"
 #include "../core/type_traits.hpp"
@@ -40,16 +39,18 @@ struct dense_map_node final {
         : next{pos},
           element{std::forward<Args>(args)...} {}
 
-    template<typename... Args>
-    dense_map_node(std::allocator_arg_t, const allocator_like auto &allocator, const std::size_t pos, Args &&...args)
+    template<typename Allocator, typename... Args>
+    dense_map_node(std::allocator_arg_t, const Allocator &allocator, const std::size_t pos, Args &&...args)
         : next{pos},
           element{entt::make_obj_using_allocator<value_type>(allocator, std::forward<Args>(args)...)} {}
 
-    dense_map_node(std::allocator_arg_t, const allocator_like auto &allocator, const dense_map_node &other)
+    template<typename Allocator>
+    dense_map_node(std::allocator_arg_t, const Allocator &allocator, const dense_map_node &other)
         : next{other.next},
           element{entt::make_obj_using_allocator<value_type>(allocator, other.element)} {}
 
-    dense_map_node(std::allocator_arg_t, const allocator_like auto &allocator, dense_map_node &&other)
+    template<typename Allocator>
+    dense_map_node(std::allocator_arg_t, const Allocator &allocator, dense_map_node &&other)
         : next{other.next},
           element{entt::make_obj_using_allocator<value_type>(allocator, std::move(other.element))} {}
 
@@ -227,8 +228,9 @@ class dense_map_local_iterator final {
  * @tparam Type Mapped type of the associative container.
  * @tparam Hash Type of function to use to hash the keys.
  * @tparam KeyEqual Type of function to use to compare the keys for equality.
+ * @tparam Allocator Type of allocator used to manage memory and elements.
  */
-template<typename Key, typename Type, typename Hash, typename KeyEqual, allocator_like Allocator>
+template<typename Key, typename Type, typename Hash, typename KeyEqual, typename Allocator>
 class dense_map {
     static constexpr float default_threshold = 0.875f;
     static constexpr std::size_t minimum_capacity = 8u;
@@ -1015,7 +1017,7 @@ class dense_map {
 /*! @cond ENTT_INTERNAL */
 namespace std {
 
-template<typename Key, typename Value, entt::allocator_like Allocator>
+template<typename Key, typename Value, typename Allocator>
 struct uses_allocator<entt::internal::dense_map_node<Key, Value>, Allocator>
     : std::true_type {};
 

src/entt/container/dense_set.hpp

@@ -190,8 +190,9 @@ class dense_set_local_iterator final {
  * @tparam Type Value type of the associative container.
  * @tparam Hash Type of function to use to hash the values.
  * @tparam KeyEqual Type of function to use to compare the values for equality.
+ * @tparam Allocator Type of allocator used to manage memory and elements.
  */
-template<typename Type, typename Hash, typename KeyEqual, allocator_like Allocator>
+template<typename Type, typename Hash, typename KeyEqual, typename Allocator>
 class dense_set {
     static constexpr float default_threshold = 0.875f;
     static constexpr std::size_t minimum_capacity = 8u;

src/entt/container/fwd.hpp

@@ -5,7 +5,6 @@
 #include <memory>
 #include <utility>
 #include <vector>
-#include "../core/concepts.hpp"
 
 namespace entt {
 
@@ -14,14 +13,14 @@ template<
     typename Type,
     typename = std::hash<Key>,
     typename = std::equal_to<>,
-    allocator_like = std::allocator<std::pair<const Key, Type>>>
+    typename = std::allocator<std::pair<const Key, Type>>>
 class dense_map;
 
 template<
     typename Type,
     typename = std::hash<Type>,
     typename = std::equal_to<>,
-    allocator_like = std::allocator<Type>>
+    typename = std::allocator<Type>>
 class dense_set;
 
 template<typename...>

src/entt/container/table.hpp

@@ -170,9 +170,11 @@ class basic_table {
 
     /**
      * @brief Constructs the underlying containers using a given allocator.
+     * @tparam Allocator Type of allocator.
      * @param allocator A valid allocator.
      */
-    explicit basic_table(const allocator_like auto &allocator)
+    template<typename Allocator>
+    explicit basic_table(const Allocator &allocator)
         : payload{Container{allocator}...} {}
 
     /**
@@ -422,7 +424,7 @@ class basic_table {
 /*! @cond ENTT_INTERNAL */
 namespace std {
 
-template<typename... Container, entt::allocator_like Allocator>
+template<typename... Container, typename Allocator>
 struct uses_allocator<entt::basic_table<Container...>, Allocator>
     : std::bool_constant<(std::uses_allocator_v<Container, Allocator> && ...)> {};
 

src/entt/core/concepts.hpp

@@ -1,7 +1,6 @@
 #ifndef ENTT_CORE_CONCEPTS_HPP
 #define ENTT_CORE_CONCEPTS_HPP
 
-#include <concepts>
 #include <type_traits>
 
 namespace entt {
@@ -13,16 +12,6 @@ namespace entt {
 template<typename Type>
 concept cvref_unqualified = std::is_same_v<std::remove_cvref_t<Type>, Type>;
 
-/**
- * @brief Specifies that a type is likely an allocator type.
- * @tparam Type Type to check.
- */
-template<typename Type>
-concept allocator_like = requires(Type alloc, typename Type::value_type *value) {
-    { alloc.allocate(0) } -> std::same_as<decltype(value)>;
-    { alloc.deallocate(value, 0) } -> std::same_as<void>;
-};
-
 } // namespace entt
 
 #endif

src/entt/core/memory.hpp

@@ -7,7 +7,6 @@
 #include <type_traits>
 #include <utility>
 #include "../config/config.h"
-#include "../core/concepts.hpp"
 #include "../stl/memory.hpp"
 
 namespace entt {
@@ -18,7 +17,7 @@ namespace entt {
  * @param lhs A valid allocator.
  * @param rhs Another valid allocator.
  */
-template<allocator_like Allocator>
+template<typename Allocator>
 constexpr void propagate_on_container_copy_assignment([[maybe_unused]] Allocator &lhs, [[maybe_unused]] Allocator &rhs) noexcept {
     if constexpr(std::allocator_traits<Allocator>::propagate_on_container_copy_assignment::value) {
         lhs = rhs;
@@ -31,7 +30,7 @@ constexpr void propagate_on_container_copy_assignment([[maybe_unused]] Allocator
  * @param lhs A valid allocator.
  * @param rhs Another valid allocator.
  */
-template<allocator_like Allocator>
+template<typename Allocator>
 constexpr void propagate_on_container_move_assignment([[maybe_unused]] Allocator &lhs, [[maybe_unused]] Allocator &rhs) noexcept {
     if constexpr(std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value) {
         lhs = std::move(rhs);
@@ -44,7 +43,7 @@ constexpr void propagate_on_container_move_assignment([[maybe_unused]] Allocator
  * @param lhs A valid allocator.
  * @param rhs Another valid allocator.
  */
-template<allocator_like Allocator>
+template<typename Allocator>
 constexpr void propagate_on_container_swap([[maybe_unused]] Allocator &lhs, [[maybe_unused]] Allocator &rhs) noexcept {
     if constexpr(std::allocator_traits<Allocator>::propagate_on_container_swap::value) {
         using std::swap;
@@ -58,7 +57,7 @@ constexpr void propagate_on_container_swap([[maybe_unused]] Allocator &lhs, [[ma
  * @brief Deleter for allocator-aware unique pointers (waiting for C++20).
  * @tparam Allocator Type of allocator used to manage memory and elements.
  */
-template<allocator_like Allocator>
+template<typename Allocator>
 struct allocation_deleter: private Allocator {
     /*! @brief Allocator type. */
     using allocator_type = Allocator;
@@ -92,7 +91,7 @@ struct allocation_deleter: private Allocator {
  * @param args Parameters to use to construct the object.
  * @return A properly initialized unique pointer with a custom deleter.
  */
-template<typename Type, allocator_like Allocator, typename... Args>
+template<typename Type, typename Allocator, typename... Args>
 constexpr auto allocate_unique(Allocator &allocator, Args &&...args) {
     static_assert(!std::is_array_v<Type>, "Array types are not supported");
 
@@ -118,7 +117,7 @@ namespace internal {
 
 template<typename Type>
 struct uses_allocator_construction {
-    template<allocator_like Allocator, typename... Params>
+    template<typename Allocator, typename... Params>
     static constexpr auto args([[maybe_unused]] const Allocator &allocator, Params &&...params) noexcept {
         if constexpr(!std::uses_allocator_v<Type, Allocator> && std::is_constructible_v<Type, Params...>) {
             return std::forward_as_tuple(std::forward<Params>(params)...);
@@ -139,30 +138,31 @@ template<typename Type, typename Other>
 struct uses_allocator_construction<std::pair<Type, Other>> {
     using type = std::pair<Type, Other>;
 
-    template<typename First, typename Second>
-    static constexpr auto args(const allocator_like auto &allocator, std::piecewise_construct_t, First &&first, Second &&second) noexcept {
+    template<typename Allocator, typename First, typename Second>
+    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<Type>::args(allocator, std::forward<decltype(curr)>(curr)...); }, std::forward<First>(first)),
             std::apply([&allocator](auto &&...curr) { return uses_allocator_construction<Other>::args(allocator, std::forward<decltype(curr)>(curr)...); }, std::forward<Second>(second)));
     }
 
-    static constexpr auto args(const allocator_like auto &allocator) noexcept {
+    template<typename Allocator>
+    static constexpr auto args(const Allocator &allocator) noexcept {
         return uses_allocator_construction<type>::args(allocator, std::piecewise_construct, std::tuple<>{}, std::tuple<>{});
     }
 
-    template<typename First, typename Second>
-    static constexpr auto args(const allocator_like auto &allocator, First &&first, Second &&second) noexcept {
+    template<typename Allocator, typename First, typename Second>
+    static constexpr auto args(const Allocator &allocator, First &&first, Second &&second) noexcept {
         return uses_allocator_construction<type>::args(allocator, std::piecewise_construct, std::forward_as_tuple(std::forward<First>(first)), std::forward_as_tuple(std::forward<Second>(second)));
     }
 
-    template<typename First, typename Second>
-    static constexpr auto args(const allocator_like auto &allocator, const std::pair<First, Second> &value) noexcept {
+    template<typename Allocator, typename First, typename Second>
+    static constexpr auto args(const Allocator &allocator, const std::pair<First, Second> &value) noexcept {
         return uses_allocator_construction<type>::args(allocator, std::piecewise_construct, std::forward_as_tuple(value.first), std::forward_as_tuple(value.second));
     }
 
-    template<typename First, typename Second>
-    static constexpr auto args(const allocator_like auto &allocator, std::pair<First, Second> &&value) noexcept {
+    template<typename Allocator, typename First, typename Second>
+    static constexpr auto args(const Allocator &allocator, std::pair<First, Second> &&value) noexcept {
         return uses_allocator_construction<type>::args(allocator, std::piecewise_construct, std::forward_as_tuple(std::move(value.first)), std::forward_as_tuple(std::move(value.second)));
     }
 };
@@ -177,13 +177,14 @@ struct uses_allocator_construction<std::pair<Type, Other>> {
  * 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<typename Type, typename... Args>
-constexpr auto uses_allocator_construction_args(const allocator_like auto &allocator, Args &&...args) noexcept {
+template<typename Type, typename Allocator, typename... Args>
+constexpr auto uses_allocator_construction_args(const Allocator &allocator, Args &&...args) noexcept {
     return internal::uses_allocator_construction<Type>::args(allocator, std::forward<Args>(args)...);
 }
 
@@ -194,13 +195,14 @@ constexpr auto uses_allocator_construction_args(const allocator_like auto &alloc
  * 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<typename Type, typename... Args>
-constexpr Type make_obj_using_allocator(const allocator_like auto &allocator, Args &&...args) {
+template<typename Type, typename Allocator, typename... Args>
+constexpr Type make_obj_using_allocator(const Allocator &allocator, Args &&...args) {
     return std::make_from_tuple<Type>(internal::uses_allocator_construction<Type>::args(allocator, std::forward<Args>(args)...));
 }
 
@@ -211,14 +213,15 @@ constexpr Type make_obj_using_allocator(const allocator_like auto &allocator, Ar
  * 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<typename Type, typename... Args>
-constexpr Type *uninitialized_construct_using_allocator(Type *value, const allocator_like auto &allocator, Args &&...args) {
+template<typename Type, typename Allocator, typename... Args>
+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<decltype(curr)>(curr)...); }, internal::uses_allocator_construction<Type>::args(allocator, std::forward<Args>(args)...));
 }
 

src/entt/entity/fwd.hpp

@@ -47,10 +47,10 @@ enum class deletion_policy : std::uint8_t {
 template<cvref_unqualified Type, entity_like Entity = entity>
 struct component_traits;
 
-template<entity_like Entity = entity, allocator_like = std::allocator<Entity>>
+template<entity_like Entity = entity, typename = std::allocator<Entity>>
 class basic_sparse_set;
 
-template<typename Type, entity_like = entity, allocator_like = std::allocator<Type>>
+template<typename Type, entity_like = entity, typename = std::allocator<Type>>
 class basic_storage;
 
 template<typename, typename>
@@ -59,13 +59,13 @@ class basic_sigh_mixin;
 template<typename, typename>
 class basic_reactive_mixin;
 
-template<entity_like Entity = entity, allocator_like = std::allocator<Entity>>
+template<entity_like Entity = entity, typename = std::allocator<Entity>>
 class basic_registry;
 
 template<typename, typename>
 class basic_view;
 
-template<typename Type, allocator_like = std::allocator<Type *>>
+template<typename Type, typename = std::allocator<Type *>>
 class basic_runtime_view;
 
 template<typename, typename, typename>
@@ -241,7 +241,7 @@ struct type_list_transform<owned_t<Type...>, Op> {
  * @tparam Entity A valid entity type.
  * @tparam Allocator Type of allocator used to manage memory and elements.
  */
-template<typename Type, entity_like Entity = entity, allocator_like Allocator = std::allocator<Type>>
+template<typename Type, entity_like Entity = entity, typename Allocator = std::allocator<Type>>
 struct storage_type {
     /*! @brief Type-to-storage conversion result. */
     using type = ENTT_STORAGE(sigh_mixin, basic_storage<Type, Entity, Allocator>);
@@ -255,7 +255,7 @@ struct reactive final {};
  * @tparam Entity A valid entity type.
  * @tparam Allocator Type of allocator used to manage memory and elements.
  */
-template<entity_like Entity, allocator_like Allocator>
+template<entity_like Entity, typename Allocator>
 struct storage_type<reactive, Entity, Allocator> {
     /*! @brief Type-to-storage conversion result. */
     using type = ENTT_STORAGE(reactive_mixin, basic_storage<reactive, Entity, Allocator>);
@@ -274,7 +274,7 @@ using storage_type_t = storage_type<Args...>::type;
  * @tparam Entity A valid entity type.
  * @tparam Allocator Type of allocator used to manage memory and elements.
  */
-template<typename Type, entity_like Entity = entity, allocator_like Allocator = std::allocator<std::remove_const_t<Type>>>
+template<typename Type, entity_like Entity = entity, typename Allocator = std::allocator<std::remove_const_t<Type>>>
 struct storage_for {
     /*! @brief Type-to-storage conversion result. */
     using type = constness_as_t<storage_type_t<std::remove_const_t<Type>, Entity, Allocator>, Type>;

src/entt/entity/group.hpp

@@ -10,7 +10,6 @@
 #include <utility>
 #include "../config/config.h"
 #include "../core/algorithm.hpp"
-#include "../core/concepts.hpp"
 #include "../core/fwd.hpp"
 #include "../core/iterator.hpp"
 #include "../core/type_info.hpp"
@@ -206,8 +205,8 @@ class group_handler<Type, 0u, Get, Exclude> final: public group_descriptor {
 public:
     using common_type = Type;
 
-    template<typename... GType, typename... EType>
-    group_handler(const allocator_like auto &allocator, std::tuple<GType &...> gpool, std::tuple<EType &...> epool)
+    template<typename Allocator, typename... GType, typename... EType>
+    group_handler(const Allocator &allocator, std::tuple<GType &...> gpool, std::tuple<EType &...> epool)
         : pools{std::apply([](auto &&...cpool) { return std::array<common_type *, Get>{&cpool...}; }, gpool)},
           filter{std::apply([](auto &&...cpool) { return std::array<common_type *, Exclude>{&cpool...}; }, epool)},
           elem{allocator} {

src/entt/entity/registry.hpp

@@ -131,7 +131,7 @@ class registry_storage_iterator final {
     It it;
 };
 
-template<allocator_like Allocator>
+template<typename Allocator>
 class registry_context {
     using alloc_traits = std::allocator_traits<Allocator>;
     using allocator_type = alloc_traits::template rebind_alloc<std::pair<const id_type, basic_any<0u>>>;
@@ -210,7 +210,7 @@ class registry_context {
  * @tparam Entity A valid entity type.
  * @tparam Allocator Type of allocator used to manage memory and elements.
  */
-template<entity_like Entity, allocator_like Allocator>
+template<entity_like Entity, typename Allocator>
 class basic_registry {
     using base_type = basic_sparse_set<Entity, Allocator>;
     using alloc_traits = std::allocator_traits<Allocator>;

src/entt/entity/runtime_view.hpp

@@ -6,7 +6,6 @@
 #include <iterator>
 #include <utility>
 #include <vector>
-#include "../core/concepts.hpp"
 #include "entity.hpp"
 #include "fwd.hpp"
 
@@ -116,7 +115,7 @@ class runtime_view_iterator final {
  * @tparam Type Common base type.
  * @tparam Allocator Type of allocator used to manage memory and elements.
  */
-template<typename Type, allocator_like Allocator>
+template<typename Type, typename Allocator>
 class basic_runtime_view {
     using alloc_traits = std::allocator_traits<Allocator>;
     static_assert(std::is_same_v<typename alloc_traits::value_type, Type *>, "Invalid value type");