stl: std::allocator_traits

src/entt/container/dense_map.hpp

@@ -234,7 +234,7 @@ class dense_map {
     static constexpr stl::size_t placeholder_position = internal::dense_map_placeholder_position;
 
     using node_type = internal::dense_map_node<Key, Type>;
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, stl::pair<const Key, Type>>, "Invalid value type");
     using sparse_container_type = stl::vector<stl::size_t, typename alloc_traits::template rebind_alloc<stl::size_t>>;
     using packed_container_type = stl::vector<node_type, typename alloc_traits::template rebind_alloc<node_type>>;

src/entt/container/dense_set.hpp

@@ -198,7 +198,7 @@ class dense_set {
     static constexpr stl::size_t placeholder_position = internal::dense_set_placeholder_position;
 
     using node_type = stl::pair<stl::size_t, Type>;
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
     using sparse_container_type = stl::vector<stl::size_t, typename alloc_traits::template rebind_alloc<stl::size_t>>;
     using packed_container_type = stl::vector<node_type, typename alloc_traits::template rebind_alloc<node_type>>;

src/entt/core/memory.hpp

@@ -18,7 +18,7 @@ namespace entt {
  */
 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) {
+    if constexpr(stl::allocator_traits<Allocator>::propagate_on_container_copy_assignment::value) {
         lhs = rhs;
     }
 }
@@ -31,7 +31,7 @@ constexpr void propagate_on_container_copy_assignment([[maybe_unused]] 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) {
+    if constexpr(stl::allocator_traits<Allocator>::propagate_on_container_move_assignment::value) {
         lhs = stl::move(rhs);
     }
 }
@@ -44,7 +44,7 @@ constexpr void propagate_on_container_move_assignment([[maybe_unused]] 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) {
+    if constexpr(stl::allocator_traits<Allocator>::propagate_on_container_swap::value) {
         using std::swap;
         swap(lhs, rhs);
     } else {
@@ -61,7 +61,7 @@ struct allocation_deleter: private Allocator {
     /*! @brief Allocator type. */
     using allocator_type = Allocator;
     /*! @brief Pointer type. */
-    using pointer = std::allocator_traits<Allocator>::pointer;
+    using pointer = stl::allocator_traits<Allocator>::pointer;
 
     /**
      * @brief Inherited constructors.
@@ -75,7 +75,7 @@ struct allocation_deleter: private Allocator {
      * @param ptr A valid pointer to an object of the given type.
      */
     constexpr void operator()(pointer ptr) noexcept(stl::is_nothrow_destructible_v<typename allocator_type::value_type>) {
-        using alloc_traits = std::allocator_traits<Allocator>;
+        using alloc_traits = stl::allocator_traits<Allocator>;
         alloc_traits::destroy(*this, stl::to_address(ptr));
         alloc_traits::deallocate(*this, ptr, 1u);
     }
@@ -94,7 +94,7 @@ template<typename Type, typename Allocator, typename... Args>
 constexpr auto allocate_unique(Allocator &allocator, Args &&...args) {
     static_assert(!stl::is_array_v<Type>, "Array types are not supported");
 
-    using alloc_traits = std::allocator_traits<Allocator>::template rebind_traits<Type>;
+    using alloc_traits = stl::allocator_traits<Allocator>::template rebind_traits<Type>;
     using allocator_type = alloc_traits::allocator_type;
 
     allocator_type alloc{allocator};

src/entt/entity/mixin.hpp

@@ -393,7 +393,7 @@ class basic_reactive_mixin final: public Type {
     using underlying_type = Type;
     using owner_type = Registry;
 
-    using alloc_traits = std::allocator_traits<typename underlying_type::allocator_type>;
+    using alloc_traits = stl::allocator_traits<typename underlying_type::allocator_type>;
     using basic_registry_type = basic_registry<typename owner_type::entity_type, typename owner_type::allocator_type>;
     using container_type = stl::vector<connection, typename alloc_traits::template rebind_alloc<connection>>;
 

src/entt/entity/registry.hpp

@@ -131,7 +131,7 @@ private:
 
 template<typename Allocator>
 class registry_context {
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     using allocator_type = alloc_traits::template rebind_alloc<stl::pair<const id_type, basic_any<0u>>>;
 
 public:
@@ -211,7 +211,7 @@ private:
 template<typename Entity, typename Allocator>
 class basic_registry {
     using base_type = basic_sparse_set<Entity, Allocator>;
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, Entity>, "Invalid value type");
     // stl::shared_ptr because of its type erased allocator which is useful here
     using pool_container_type = dense_map<id_type, stl::shared_ptr<base_type>, stl::identity, std::equal_to<>, typename alloc_traits::template rebind_alloc<stl::pair<const id_type, stl::shared_ptr<base_type>>>>;

src/entt/entity/runtime_view.hpp

@@ -117,7 +117,7 @@ private:
  */
 template<typename Type, typename Allocator>
 class basic_runtime_view {
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, Type *>, "Invalid value type");
     using container_type = stl::vector<Type *, Allocator>;
 

src/entt/entity/sparse_set.hpp

@@ -137,7 +137,7 @@ private:
  */
 template<typename Entity, typename Allocator>
 class basic_sparse_set {
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, Entity>, "Invalid value type");
     using sparse_container_type = stl::vector<typename alloc_traits::pointer, typename alloc_traits::template rebind_alloc<typename alloc_traits::pointer>>;
     using packed_container_type = stl::vector<Entity, Allocator>;

src/entt/entity/storage.hpp

@@ -31,7 +31,7 @@ class storage_iterator final {
     friend class storage_iterator;
 
     using container_type = stl::remove_const_t<Container>;
-    using alloc_traits = std::allocator_traits<typename container_type::allocator_type>;
+    using alloc_traits = stl::allocator_traits<typename container_type::allocator_type>;
 
     using iterator_traits = stl::iterator_traits<stl::conditional_t<
         stl::is_const_v<Container>,
@@ -205,8 +205,8 @@ private:
  * @tparam Allocator Type of allocator used to manage memory and elements.
  */
 template<typename Type, typename Entity, typename Allocator>
-class basic_storage: public basic_sparse_set<Entity, typename std::allocator_traits<Allocator>::template rebind_alloc<Entity>> {
-    using alloc_traits = std::allocator_traits<Allocator>;
+class basic_storage: public basic_sparse_set<Entity, typename stl::allocator_traits<Allocator>::template rebind_alloc<Entity>> {
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
     using container_type = stl::vector<typename alloc_traits::pointer, typename alloc_traits::template rebind_alloc<typename alloc_traits::pointer>>;
     using underlying_type = basic_sparse_set<Entity, typename alloc_traits::template rebind_alloc<Entity>>;
@@ -774,8 +774,8 @@ private:
 template<typename Type, typename Entity, typename Allocator>
 requires (component_traits<Type, Entity>::page_size == 0u)
 class basic_storage<Type, Entity, Allocator>
-    : public basic_sparse_set<Entity, typename std::allocator_traits<Allocator>::template rebind_alloc<Entity>> {
-    using alloc_traits = std::allocator_traits<Allocator>;
+    : public basic_sparse_set<Entity, typename stl::allocator_traits<Allocator>::template rebind_alloc<Entity>> {
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
     using traits_type = component_traits<Type, Entity>;
 
@@ -957,7 +957,7 @@ public:
 template<typename Entity, typename Allocator>
 class basic_storage<Entity, Entity, Allocator>
     : public basic_sparse_set<Entity, Allocator> {
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, Entity>, "Invalid value type");
     using underlying_iterator = basic_sparse_set<Entity, Allocator>::basic_iterator;
     using traits_type = entt_traits<Entity>;

src/entt/graph/adjacency_matrix.hpp

@@ -86,7 +86,7 @@ private:
  */
 template<std::derived_from<directed_tag> Category, typename Allocator>
 class adjacency_matrix {
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, stl::size_t>, "Invalid value type");
     using container_type = stl::vector<stl::size_t, typename alloc_traits::template rebind_alloc<stl::size_t>>;
 

src/entt/graph/flow.hpp

@@ -28,7 +28,7 @@ namespace entt {
  */
 template<typename Allocator>
 class basic_flow {
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, id_type>, "Invalid value type");
     using task_container_type = dense_set<id_type, stl::identity, std::equal_to<>, typename alloc_traits::template rebind_alloc<id_type>>;
     using ro_rw_container_type = stl::vector<stl::pair<stl::size_t, bool>, typename alloc_traits::template rebind_alloc<stl::pair<stl::size_t, bool>>>;

src/entt/process/scheduler.hpp

@@ -35,7 +35,7 @@ namespace entt {
 template<typename Delta, typename Allocator>
 class basic_scheduler {
     using base_type = basic_process<Delta, Allocator>;
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     using container_allocator = alloc_traits::template rebind_alloc<stl::shared_ptr<base_type>>;
     using container_type = stl::vector<stl::shared_ptr<base_type>, container_allocator>;
 

src/entt/resource/cache.hpp

@@ -125,7 +125,7 @@ private:
  */
 template<typename Type, typename Loader, typename Allocator>
 class resource_cache {
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     static_assert(stl::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
     using container_allocator = alloc_traits::template rebind_alloc<stl::pair<const id_type, typename Loader::result_type>>;
     using container_type = dense_map<id_type, typename Loader::result_type, stl::identity, std::equal_to<>, container_allocator>;

src/entt/signal/dispatcher.hpp

@@ -31,7 +31,7 @@ struct basic_dispatcher_handler {
 
 template<cvref_unqualified Type, typename Allocator>
 class dispatcher_handler final: public basic_dispatcher_handler {
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     using signal_type = sigh<void(Type &), Allocator>;
     using container_type = stl::vector<Type, typename alloc_traits::template rebind_alloc<Type>>;
 
@@ -111,7 +111,7 @@ class basic_dispatcher {
     // stl::shared_ptr because of its type erased allocator which is useful here
     using mapped_type = stl::shared_ptr<internal::basic_dispatcher_handler>;
 
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     using container_allocator = alloc_traits::template rebind_alloc<stl::pair<const key_type, mapped_type>>;
     using container_type = dense_map<key_type, mapped_type, stl::identity, std::equal_to<>, container_allocator>;
 

src/entt/signal/emitter.hpp

@@ -37,7 +37,7 @@ class emitter {
     using key_type = id_type;
     using mapped_type = std::function<void(void *)>;
 
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     using container_allocator = alloc_traits::template rebind_alloc<stl::pair<const key_type, mapped_type>>;
     using container_type = dense_map<key_type, mapped_type, stl::identity, std::equal_to<>, container_allocator>;
 

src/entt/signal/sigh.hpp

@@ -54,7 +54,7 @@ template<typename Ret, typename... Args, typename Allocator>
 class sigh<Ret(Args...), Allocator> {
     friend class sink<sigh<Ret(Args...), Allocator>>;
 
-    using alloc_traits = std::allocator_traits<Allocator>;
+    using alloc_traits = stl::allocator_traits<Allocator>;
     using delegate_type = delegate<Ret(Args...)>;
     using container_type = stl::vector<delegate_type, typename alloc_traits::template rebind_alloc<delegate_type>>;
 

src/entt/stl/memory.hpp

@@ -8,6 +8,7 @@
 /*! @cond ENTT_INTERNAL */
 namespace entt::stl {
 
+using std::allocator_traits;
 using std::make_unique;
 using std::pointer_traits;
 using std::shared_ptr;