From 8713d0a90ddac0052bb583477a2aa4025eb398b8 Mon Sep 17 00:00:00 2001
From: Michele Caini <michele.caini@gmail.com>
Date: Sun, 25 Aug 2019 23:14:08 +0200
Subject: [PATCH] decoupling pools and components

---
 src/entt/entity/component.hpp                 |  37 +++++
 .../{storage.hpp => default_storage.hpp}      |  23 ++--
 src/entt/entity/group.hpp                     |  10 +-
 src/entt/entity/observer.hpp                  |   4 +-
 src/entt/entity/registry.hpp                  |  20 +--
 src/entt/entity/view.hpp                      |   8 +-
 src/entt/entt.hpp                             |   3 +-
 test/CMakeLists.txt                           |   2 +-
 .../{storage.cpp => default_storage.cpp}      | 130 +++++++++---------
 9 files changed, 135 insertions(+), 102 deletions(-)
 create mode 100644 src/entt/entity/component.hpp
 rename src/entt/entity/{storage.hpp => default_storage.hpp} (97%)
 rename test/entt/entity/{storage.cpp => default_storage.cpp} (85%)

diff --git a/src/entt/entity/component.hpp b/src/entt/entity/component.hpp
new file mode 100644
index 0000000000..48a213f7ef
--- /dev/null
+++ b/src/entt/entity/component.hpp
@@ -0,0 +1,37 @@
+#ifndef ENTT_ENTITY_COMPONENT_HPP
+#define ENTT_ENTITY_COMPONENT_HPP
+
+
+#include <type_traits>
+#include "default_storage.hpp"
+
+
+namespace entt {
+
+
+template<typename>
+struct component_traits;
+
+
+template<typename Type, typename = std::void_t<>>
+struct component_pool {
+    template<typename Entity>
+    using type = default_storage<Entity, Type>;
+};
+
+
+template<typename Type>
+struct component_pool<Type, std::void_t<typename component_traits<Type>::pool_type>> {
+    template<typename Entity>
+    using type = typename component_traits<Type>::pool_type;
+};
+
+
+template<typename Entity, typename Type>
+using component_pool_t = typename component_pool<Type>::template type<Entity>;
+
+
+}
+
+
+#endif // ENTT_ENTITY_COMPONENT_HPP
diff --git a/src/entt/entity/storage.hpp b/src/entt/entity/default_storage.hpp
similarity index 97%
rename from src/entt/entity/storage.hpp
rename to src/entt/entity/default_storage.hpp
index d27cc2123e..44d91cdf5e 100644
--- a/src/entt/entity/storage.hpp
+++ b/src/entt/entity/default_storage.hpp
@@ -1,5 +1,5 @@
-#ifndef ENTT_ENTITY_STORAGE_HPP
-#define ENTT_ENTITY_STORAGE_HPP
+#ifndef ENTT_ENTITY_DEFAULT_STORAGE_HPP
+#define ENTT_ENTITY_DEFAULT_STORAGE_HPP
 
 
 #include <algorithm>
@@ -19,7 +19,7 @@ namespace entt {
 
 
 /**
- * @brief Basic storage implementation.
+ * @brief Default storage implementation.
  *
  * This class is a refinement of a sparse set that associates an object to an
  * entity. The main purpose of this class is to extend sparse sets to store
@@ -48,13 +48,13 @@ namespace entt {
  * @tparam Type Type of objects assigned to the entities.
  */
 template<typename Entity, typename Type, typename = std::void_t<>>
-class basic_storage: public sparse_set<Entity> {
+class default_storage: public sparse_set<Entity> {
     using underlying_type = sparse_set<Entity>;
     using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
     template<bool Const>
     class iterator {
-        friend class basic_storage<Entity, Type>;
+        friend class default_storage<Entity, Type>;
 
         using instance_type = std::conditional_t<Const, const std::vector<Type>, std::vector<Type>>;
         using index_type = typename traits_type::difference_type;
@@ -490,14 +490,14 @@ class basic_storage: public sparse_set<Entity> {
 };
 
 
-/*! @copydoc basic_storage */
+/*! @copydoc default_storage */
 template<typename Entity, typename Type>
-class basic_storage<Entity, Type, std::enable_if_t<std::is_empty_v<Type>>>: public sparse_set<Entity> {
+class default_storage<Entity, Type, std::enable_if_t<std::is_empty_v<Type>>>: public sparse_set<Entity> {
     using traits_type = entt_traits<std::underlying_type_t<Entity>>;
     using underlying_type = sparse_set<Entity>;
 
     class iterator {
-        friend class basic_storage<Entity, Type>;
+        friend class default_storage<Entity, Type>;
 
         using index_type = typename traits_type::difference_type;
 
@@ -693,12 +693,7 @@ class basic_storage<Entity, Type, std::enable_if_t<std::is_empty_v<Type>>>: publ
     }
 };
 
-/*! @copydoc basic_storage */
-template<typename Entity, typename Type>
-struct storage: basic_storage<Entity, Type> {};
-
-
 }
 
 
-#endif // ENTT_ENTITY_STORAGE_HPP
+#endif // ENTT_ENTITY_DEFAULT_STORAGE_HPP
diff --git a/src/entt/entity/group.hpp b/src/entt/entity/group.hpp
index d00a555c6d..c863fd9db3 100644
--- a/src/entt/entity/group.hpp
+++ b/src/entt/entity/group.hpp
@@ -8,7 +8,7 @@
 #include "../config/config.h"
 #include "../core/type_traits.hpp"
 #include "sparse_set.hpp"
-#include "storage.hpp"
+#include "component.hpp"
 #include "utility.hpp"
 #include "fwd.hpp"
 
@@ -72,10 +72,10 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get, Other...>> {
     friend class basic_registry<Entity>;
 
     template<typename Component>
-    using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
+    using pool_type = std::conditional_t<std::is_const_v<Component>, const component_pool_t<Entity, std::remove_const_t<Component>>, component_pool_t<Entity, Component>>;
 
     // we could use pool_type<Type> *..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug)
-    basic_group(sparse_set<Entity> *ref, storage<Entity, std::remove_const_t<Get>> *get, storage<Entity, std::remove_const_t<Other>> *... other) ENTT_NOEXCEPT
+    basic_group(sparse_set<Entity> *ref, pool_type<Get> *get, pool_type<Other> *... other) ENTT_NOEXCEPT
         : handler{ref},
           pools{get, other...}
     {}
@@ -492,13 +492,13 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned, Other...>
     friend class basic_registry<Entity>;
 
     template<typename Component>
-    using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
+    using pool_type = std::conditional_t<std::is_const_v<Component>, const component_pool_t<Entity, std::remove_const_t<Component>>, component_pool_t<Entity, Component>>;
 
     template<typename Component>
     using component_iterator_type = decltype(std::declval<pool_type<Component>>().begin());
 
     // we could use pool_type<Type> *..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug)
-    basic_group(const typename basic_registry<Entity>::size_type *sz, storage<Entity, std::remove_const_t<Owned>> *owned, storage<Entity, std::remove_const_t<Other>> *... other, storage<Entity, std::remove_const_t<Get>> *... get) ENTT_NOEXCEPT
+    basic_group(const typename basic_registry<Entity>::size_type *sz, pool_type<Owned> *owned, pool_type<Other> *... other, pool_type<Get> *... get) ENTT_NOEXCEPT
         : length{sz},
           pools{owned, other..., get...}
     {}
diff --git a/src/entt/entity/observer.hpp b/src/entt/entity/observer.hpp
index 410464bd8d..c62dcc5365 100644
--- a/src/entt/entity/observer.hpp
+++ b/src/entt/entity/observer.hpp
@@ -10,8 +10,8 @@
 #include <type_traits>
 #include "../config/config.h"
 #include "../core/type_traits.hpp"
+#include "default_storage.hpp"
 #include "registry.hpp"
-#include "storage.hpp"
 #include "entity.hpp"
 #include "fwd.hpp"
 
@@ -428,7 +428,7 @@ class basic_observer {
 private:
     basic_registry<entity_type> *target;
     void(* release)(basic_observer &, basic_registry<entity_type> &);
-    storage<entity_type, payload_type> view;
+    default_storage<entity_type, payload_type> view;
 };
 
 
diff --git a/src/entt/entity/registry.hpp b/src/entt/entity/registry.hpp
index 1807de4328..2a63e70232 100644
--- a/src/entt/entity/registry.hpp
+++ b/src/entt/entity/registry.hpp
@@ -18,8 +18,8 @@
 #include "../signal/sigh.hpp"
 #include "runtime_view.hpp"
 #include "sparse_set.hpp"
+#include "component.hpp"
 #include "snapshot.hpp"
-#include "storage.hpp"
 #include "utility.hpp"
 #include "entity.hpp"
 #include "group.hpp"
@@ -51,13 +51,13 @@ class basic_registry {
     };
 
     template<typename Component>
-    struct pool_handler: storage<Entity, Component> {
+    struct pool_handler: component_pool_t<Entity, Component> {
         group_type *group{};
 
         pool_handler() ENTT_NOEXCEPT = default;
 
-        pool_handler(const storage<Entity, Component> &other)
-            : storage<Entity, Component>{other}
+        pool_handler(const component_pool_t<Entity, Component> &other)
+            : component_pool_t<Entity, Component>{other}
         {}
 
         auto on_construct() ENTT_NOEXCEPT {
@@ -75,11 +75,11 @@ class basic_registry {
         template<typename... Args>
         decltype(auto) assign(basic_registry &registry, const Entity entt, Args &&... args) {
             if constexpr(std::is_empty_v<Component>) {
-                storage<Entity, Component>::construct(entt);
+                component_pool_t<Entity, Component>::construct(entt);
                 construction.publish(entt, registry, Component{});
                 return Component{std::forward<Args>(args)...};
             } else {
-                auto &component = storage<Entity, Component>::construct(entt, std::forward<Args>(args)...);
+                auto &component = component_pool_t<Entity, Component>::construct(entt, std::forward<Args>(args)...);
                 construction.publish(entt, registry, component);
                 return component;
             }
@@ -87,7 +87,7 @@ class basic_registry {
 
         template<typename It, typename... Comp>
         auto batch(basic_registry &registry, It first, It last, const Comp &... value) {
-            auto it = storage<Entity, Component>::batch(first, last, value...);
+            auto it = component_pool_t<Entity, Component>::batch(first, last, value...);
 
             if(!construction.empty()) {
                 std::for_each(first, last, [this, &registry, it](const auto entt) mutable {
@@ -100,19 +100,19 @@ class basic_registry {
 
         void remove(basic_registry &registry, const Entity entt) {
             destruction.publish(entt, registry);
-            storage<Entity, Component>::destroy(entt);
+            component_pool_t<Entity, Component>::destroy(entt);
         }
 
         template<typename... Args>
         decltype(auto) replace(basic_registry &registry, const Entity entt, Args &&... args) {
             if constexpr(std::is_empty_v<Component>) {
-                ENTT_ASSERT((storage<Entity, Component>::has(entt)));
+                ENTT_ASSERT((component_pool_t<Entity, Component>::has(entt)));
                 update.publish(entt, registry, Component{});
                 return Component{std::forward<Args>(args)...};
             } else {
                 Component component{std::forward<Args>(args)...};
                 update.publish(entt, registry, component);
-                return (storage<Entity, Component>::get(entt) = std::move(component));
+                return (component_pool_t<Entity, Component>::get(entt) = std::move(component));
             }
         }
 
diff --git a/src/entt/entity/view.hpp b/src/entt/entity/view.hpp
index f7f1079927..f143266edf 100644
--- a/src/entt/entity/view.hpp
+++ b/src/entt/entity/view.hpp
@@ -11,7 +11,7 @@
 #include "../config/config.h"
 #include "../core/type_traits.hpp"
 #include "sparse_set.hpp"
-#include "storage.hpp"
+#include "component.hpp"
 #include "entity.hpp"
 #include "fwd.hpp"
 
@@ -64,7 +64,7 @@ class basic_view {
     friend class basic_registry<Entity>;
 
     template<typename Comp>
-    using pool_type = std::conditional_t<std::is_const_v<Comp>, const storage<Entity, std::remove_const_t<Comp>>, storage<Entity, Comp>>;
+    using pool_type = std::conditional_t<std::is_const_v<Comp>, const component_pool_t<Entity, std::remove_const_t<Comp>>, component_pool_t<Entity, Comp>>;
 
     template<typename Comp>
     using component_iterator_type = decltype(std::declval<pool_type<Comp>>().begin());
@@ -145,7 +145,7 @@ class basic_view {
     };
 
     // we could use pool_type<Component> *..., but vs complains about it and refuses to compile for unknown reasons (likely a bug)
-    basic_view(storage<Entity, std::remove_const_t<Component>> *... ref) ENTT_NOEXCEPT
+    basic_view(pool_type<Component> *... ref) ENTT_NOEXCEPT
         : pools{ref...}
     {}
 
@@ -541,7 +541,7 @@ class basic_view<Entity, Component> {
     /*! @brief A registry is allowed to create views. */
     friend class basic_registry<Entity>;
 
-    using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
+    using pool_type = std::conditional_t<std::is_const_v<Component>, const component_pool_t<Entity, std::remove_const_t<Component>>, component_pool_t<Entity, Component>>;
 
     basic_view(pool_type *ref) ENTT_NOEXCEPT
         : pool{ref}
diff --git a/src/entt/entt.hpp b/src/entt/entt.hpp
index 5705bb9d8a..04efe7e293 100644
--- a/src/entt/entt.hpp
+++ b/src/entt/entt.hpp
@@ -6,6 +6,8 @@
 #include "core/type_traits.hpp"
 #include "core/utility.hpp"
 #include "entity/actor.hpp"
+#include "entity/component.hpp"
+#include "entity/default_storage.hpp"
 #include "entity/entity.hpp"
 #include "entity/group.hpp"
 #include "entity/helper.hpp"
@@ -14,7 +16,6 @@
 #include "entity/runtime_view.hpp"
 #include "entity/snapshot.hpp"
 #include "entity/sparse_set.hpp"
-#include "entity/storage.hpp"
 #include "entity/utility.hpp"
 #include "entity/view.hpp"
 #include "locator/locator.hpp"
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 33de7031a9..b4a1fdc1c3 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -101,7 +101,7 @@ SETUP_AND_ADD_TEST(registry entt/entity/registry.cpp)
 SETUP_AND_ADD_TEST(runtime_view entt/entity/runtime_view.cpp)
 SETUP_AND_ADD_TEST(snapshot entt/entity/snapshot.cpp)
 SETUP_AND_ADD_TEST(sparse_set entt/entity/sparse_set.cpp)
-SETUP_AND_ADD_TEST(storage entt/entity/storage.cpp)
+SETUP_AND_ADD_TEST(default_storage entt/entity/default_storage.cpp)
 SETUP_AND_ADD_TEST(view entt/entity/view.cpp)
 
 # Test locator
diff --git a/test/entt/entity/storage.cpp b/test/entt/entity/default_storage.cpp
similarity index 85%
rename from test/entt/entity/storage.cpp
rename to test/entt/entity/default_storage.cpp
index fdca85466c..29ef8c4440 100644
--- a/test/entt/entity/storage.cpp
+++ b/test/entt/entity/default_storage.cpp
@@ -5,7 +5,7 @@
 #include <type_traits>
 #include <unordered_set>
 #include <gtest/gtest.h>
-#include <entt/entity/storage.hpp>
+#include <entt/entity/default_storage.hpp>
 #include <entt/entity/fwd.hpp>
 
 struct empty_type {};
@@ -20,8 +20,8 @@ struct throwing_component {
     int data;
 };
 
-TEST(Storage, Functionalities) {
-    entt::storage<entt::entity, int> pool;
+TEST(DefaultStorage, Functionalities) {
+    entt::default_storage<entt::entity, int> pool;
 
     pool.reserve(42);
 
@@ -75,13 +75,13 @@ TEST(Storage, Functionalities) {
 
     ASSERT_EQ(pool.capacity(), 0);
 
-    (void)entt::storage<entt::entity, int>{std::move(pool)};
-    entt::storage<entt::entity, int> other;
+    (void)entt::default_storage<entt::entity, int>{std::move(pool)};
+    entt::default_storage<entt::entity, int> other;
     other = std::move(pool);
 }
 
-TEST(Storage, EmptyType) {
-    entt::storage<entt::entity, empty_type> pool;
+TEST(DefaultStorage, EmptyType) {
+    entt::default_storage<entt::entity, empty_type> pool;
 
     pool.construct(entt::entity{42});
     pool.construct(entt::entity{99});
@@ -94,8 +94,8 @@ TEST(Storage, EmptyType) {
     ASSERT_TRUE((std::is_same_v<decltype(component), empty_type &&>));
 }
 
-TEST(Storage, BatchAdd) {
-    entt::storage<entt::entity, int> pool;
+TEST(DefaultStorage, BatchAdd) {
+    entt::default_storage<entt::entity, int> pool;
     entt::entity entities[2];
 
     entities[0] = entt::entity{3};
@@ -117,8 +117,8 @@ TEST(Storage, BatchAdd) {
     ASSERT_EQ(pool.get(entities[1]), 2);
 }
 
-TEST(Storage, BatchAddByCopy) {
-    entt::storage<entt::entity, int> pool;
+TEST(DefaultStorage, BatchAddByCopy) {
+    entt::default_storage<entt::entity, int> pool;
     entt::entity entities[2];
 
     entities[0] = entt::entity{3};
@@ -140,8 +140,8 @@ TEST(Storage, BatchAddByCopy) {
     ASSERT_EQ(pool.get(entities[1]), 2);
 }
 
-TEST(Storage, BatchAddEmptyType) {
-    entt::storage<entt::entity, empty_type> pool;
+TEST(DefaultStorage, BatchAddEmptyType) {
+    entt::default_storage<entt::entity, empty_type> pool;
     entt::entity entities[2];
 
     entities[0] = entt::entity{3};
@@ -160,23 +160,23 @@ TEST(Storage, BatchAddEmptyType) {
     ASSERT_TRUE((std::is_same_v<decltype(component), empty_type &&>));
 }
 
-TEST(Storage, AggregatesMustWork) {
+TEST(DefaultStorage, AggregatesMustWork) {
     struct aggregate_type { int value; };
     // the goal of this test is to enforce the requirements for aggregate types
-    entt::storage<entt::entity, aggregate_type>{}.construct(entt::entity{0}, 42);
+    entt::default_storage<entt::entity, aggregate_type>{}.construct(entt::entity{0}, 42);
 }
 
-TEST(Storage, TypesFromStandardTemplateLibraryMustWork) {
+TEST(DefaultStorage, TypesFromStandardTemplateLibraryMustWork) {
     // see #37 - this test shouldn't crash, that's all
-    entt::storage<entt::entity, std::unordered_set<int>> pool;
+    entt::default_storage<entt::entity, std::unordered_set<int>> pool;
     pool.construct(entt::entity{0}).insert(42);
     pool.destroy(entt::entity{0});
 }
 
-TEST(Storage, Iterator) {
-    using iterator_type = typename entt::storage<entt::entity, boxed_int>::iterator_type;
+TEST(DefaultStorage, Iterator) {
+    using iterator_type = typename entt::default_storage<entt::entity, boxed_int>::iterator_type;
 
-    entt::storage<entt::entity, boxed_int> pool;
+    entt::default_storage<entt::entity, boxed_int> pool;
     pool.construct(entt::entity{3}, 42);
 
     iterator_type end{pool.begin()};
@@ -215,10 +215,10 @@ TEST(Storage, Iterator) {
     ASSERT_GE(end, pool.end());
 }
 
-TEST(Storage, ConstIterator) {
-    using iterator_type = typename entt::storage<entt::entity, boxed_int>::const_iterator_type;
+TEST(DefaultStorage, ConstIterator) {
+    using iterator_type = typename entt::default_storage<entt::entity, boxed_int>::const_iterator_type;
 
-    entt::storage<entt::entity, boxed_int> pool;
+    entt::default_storage<entt::entity, boxed_int> pool;
     pool.construct(entt::entity{3}, 42);
 
     iterator_type cend{pool.cbegin()};
@@ -257,9 +257,9 @@ TEST(Storage, ConstIterator) {
     ASSERT_GE(cend, pool.cend());
 }
 
-TEST(Storage, IteratorEmptyType) {
-    using iterator_type = typename entt::storage<entt::entity, empty_type>::iterator_type;
-    entt::storage<entt::entity, empty_type> pool;
+TEST(DefaultStorage, IteratorEmptyType) {
+    using iterator_type = typename entt::default_storage<entt::entity, empty_type>::iterator_type;
+    entt::default_storage<entt::entity, empty_type> pool;
     pool.construct(entt::entity{3});
 
     iterator_type end{pool.begin()};
@@ -303,8 +303,8 @@ TEST(Storage, IteratorEmptyType) {
     ASSERT_TRUE((std::is_same_v<decltype(component), empty_type &&>));
 }
 
-TEST(Storage, Raw) {
-    entt::storage<entt::entity, int> pool;
+TEST(DefaultStorage, Raw) {
+    entt::default_storage<entt::entity, int> pool;
 
     pool.construct(entt::entity{3}, 3);
     pool.construct(entt::entity{12}, 6);
@@ -319,8 +319,8 @@ TEST(Storage, Raw) {
     ASSERT_EQ(*(pool.raw() + 2u), 9);
 }
 
-TEST(Storage, SortOrdered) {
-    entt::storage<entt::entity, boxed_int> pool;
+TEST(DefaultStorage, SortOrdered) {
+    entt::default_storage<entt::entity, boxed_int> pool;
 
     pool.construct(entt::entity{12}, boxed_int{12});
     pool.construct(entt::entity{42}, boxed_int{9});
@@ -355,8 +355,8 @@ TEST(Storage, SortOrdered) {
     ASSERT_EQ(begin, end);
 }
 
-TEST(Storage, SortReverse) {
-    entt::storage<entt::entity, boxed_int> pool;
+TEST(DefaultStorage, SortReverse) {
+    entt::default_storage<entt::entity, boxed_int> pool;
 
     pool.construct(entt::entity{12}, boxed_int{1});
     pool.construct(entt::entity{42}, boxed_int{3});
@@ -391,8 +391,8 @@ TEST(Storage, SortReverse) {
     ASSERT_EQ(begin, end);
 }
 
-TEST(Storage, SortUnordered) {
-    entt::storage<entt::entity, boxed_int> pool;
+TEST(DefaultStorage, SortUnordered) {
+    entt::default_storage<entt::entity, boxed_int> pool;
 
     pool.construct(entt::entity{12}, boxed_int{6});
     pool.construct(entt::entity{42}, boxed_int{3});
@@ -427,8 +427,8 @@ TEST(Storage, SortUnordered) {
     ASSERT_EQ(begin, end);
 }
 
-TEST(Storage, SortRange) {
-    entt::storage<entt::entity, boxed_int> pool;
+TEST(DefaultStorage, SortRange) {
+    entt::default_storage<entt::entity, boxed_int> pool;
 
     pool.construct(entt::entity{12}, boxed_int{6});
     pool.construct(entt::entity{42}, boxed_int{3});
@@ -493,9 +493,9 @@ TEST(Storage, SortRange) {
     ASSERT_EQ(begin, end);
 }
 
-TEST(Storage, RespectDisjoint) {
-    entt::storage<entt::entity, int> lhs;
-    entt::storage<entt::entity, int> rhs;
+TEST(DefaultStorage, RespectDisjoint) {
+    entt::default_storage<entt::entity, int> lhs;
+    entt::default_storage<entt::entity, int> rhs;
 
     lhs.construct(entt::entity{3}, 3);
     lhs.construct(entt::entity{12}, 6);
@@ -520,9 +520,9 @@ TEST(Storage, RespectDisjoint) {
     ASSERT_EQ(begin, end);
 }
 
-TEST(Storage, RespectOverlap) {
-    entt::storage<entt::entity, int> lhs;
-    entt::storage<entt::entity, int> rhs;
+TEST(DefaultStorage, RespectOverlap) {
+    entt::default_storage<entt::entity, int> lhs;
+    entt::default_storage<entt::entity, int> rhs;
 
     lhs.construct(entt::entity{3}, 3);
     lhs.construct(entt::entity{12}, 6);
@@ -549,9 +549,9 @@ TEST(Storage, RespectOverlap) {
     ASSERT_EQ(begin, end);
 }
 
-TEST(Storage, RespectOrdered) {
-    entt::storage<entt::entity, int> lhs;
-    entt::storage<entt::entity, int> rhs;
+TEST(DefaultStorage, RespectOrdered) {
+    entt::default_storage<entt::entity, int> lhs;
+    entt::default_storage<entt::entity, int> rhs;
 
     lhs.construct(entt::entity{1}, 0);
     lhs.construct(entt::entity{2}, 0);
@@ -595,9 +595,9 @@ TEST(Storage, RespectOrdered) {
     ASSERT_EQ(*(rhs.data() + 5u), entt::entity{5});
 }
 
-TEST(Storage, RespectReverse) {
-    entt::storage<entt::entity, int> lhs;
-    entt::storage<entt::entity, int> rhs;
+TEST(DefaultStorage, RespectReverse) {
+    entt::default_storage<entt::entity, int> lhs;
+    entt::default_storage<entt::entity, int> rhs;
 
     lhs.construct(entt::entity{1}, 0);
     lhs.construct(entt::entity{2}, 0);
@@ -641,9 +641,9 @@ TEST(Storage, RespectReverse) {
     ASSERT_EQ(*(rhs.data() + 5u), entt::entity{5});
 }
 
-TEST(Storage, RespectUnordered) {
-    entt::storage<entt::entity, int> lhs;
-    entt::storage<entt::entity, int> rhs;
+TEST(DefaultStorage, RespectUnordered) {
+    entt::default_storage<entt::entity, int> lhs;
+    entt::default_storage<entt::entity, int> rhs;
 
     lhs.construct(entt::entity{1}, 0);
     lhs.construct(entt::entity{2}, 0);
@@ -687,9 +687,9 @@ TEST(Storage, RespectUnordered) {
     ASSERT_EQ(*(rhs.data() + 5u), entt::entity{5});
 }
 
-TEST(Storage, RespectOverlapEmptyType) {
-    entt::storage<entt::entity, empty_type> lhs;
-    entt::storage<entt::entity, empty_type> rhs;
+TEST(DefaultStorage, RespectOverlapEmptyType) {
+    entt::default_storage<entt::entity, empty_type> lhs;
+    entt::default_storage<entt::entity, empty_type> rhs;
 
     lhs.construct(entt::entity{3});
     lhs.construct(entt::entity{12});
@@ -708,24 +708,24 @@ TEST(Storage, RespectOverlapEmptyType) {
     ASSERT_EQ(std::as_const(lhs).sparse_set<entt::entity>::get(entt::entity{42}), 1u);
 }
 
-TEST(Storage, CanModifyDuringIteration) {
-    entt::storage<entt::entity, int> pool;
+TEST(DefaultStorage, CanModifyDuringIteration) {
+    entt::default_storage<entt::entity, int> pool;
     pool.construct(entt::entity{0}, 42);
 
-    ASSERT_EQ(pool.capacity(), (entt::storage<entt::entity, int>::size_type{1}));
+    ASSERT_EQ(pool.capacity(), (entt::default_storage<entt::entity, int>::size_type{1}));
 
     const auto it = pool.cbegin();
-    pool.reserve(entt::storage<entt::entity, int>::size_type{2});
+    pool.reserve(entt::default_storage<entt::entity, int>::size_type{2});
 
-    ASSERT_EQ(pool.capacity(), (entt::storage<entt::entity, int>::size_type{2}));
+    ASSERT_EQ(pool.capacity(), (entt::default_storage<entt::entity, int>::size_type{2}));
 
     // this should crash with asan enabled if we break the constraint
     const auto entity = *it;
     (void)entity;
 }
 
-TEST(Storage, ReferencesGuaranteed) {
-    entt::storage<entt::entity, boxed_int> pool;
+TEST(DefaultStorage, ReferencesGuaranteed) {
+    entt::default_storage<entt::entity, boxed_int> pool;
 
     pool.construct(entt::entity{0}, 0);
     pool.construct(entt::entity{1}, 1);
@@ -752,14 +752,14 @@ TEST(Storage, ReferencesGuaranteed) {
     ASSERT_EQ(pool.get(entt::entity{1}).value, 3);
 }
 
-TEST(Storage, MoveOnlyComponent) {
+TEST(DefaultStorage, MoveOnlyComponent) {
     // the purpose is to ensure that move only components are always accepted
-    entt::storage<entt::entity, std::unique_ptr<int>> pool;
+    entt::default_storage<entt::entity, std::unique_ptr<int>> pool;
     (void)pool;
 }
 
-TEST(Storage, ConstructorExceptionDoesNotAddToStorage) {
-    entt::storage<entt::entity, throwing_component> pool;
+TEST(DefaultStorage, ConstructorExceptionDoesNotAddToStorage) {
+    entt::default_storage<entt::entity, throwing_component> pool;
 
     try {
         pool.construct(entt::entity{0});