sparse_set: split basic_sparse_set and sparse_set

src/entt/entity/fwd.hpp

@@ -8,6 +8,10 @@
 namespace entt {
 
 
+template<typename>
+class basic_sparse_set;
+
+
 template<typename>
 class basic_registry;
 
@@ -56,6 +60,10 @@ class basic_continuous_loader;
 enum class entity: id_type {};
 
 
+/*! @brief Alias declaration for the most common use case. */
+using sparse_set = basic_sparse_set<entity>;
+
+
 /*! @brief Alias declaration for the most common use case. */
 using registry = basic_registry<entity>;
 

src/entt/entity/group.hpp

@@ -77,7 +77,7 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>> {
         class proxy_iterator {
             friend class group_proxy;
 
-            using it_type = typename sparse_set<Entity>::iterator;
+            using it_type = typename basic_sparse_set<Entity>::iterator;
             using ref_type = decltype(std::tuple_cat(std::declval<std::conditional_t<is_eto_eligible_v<Get>, std::tuple<>, std::tuple<pool_type<Get> *>>>()...));
 
             proxy_iterator(it_type from, ref_type ref) ENTT_NOEXCEPT
@@ -124,7 +124,7 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>> {
             ref_type pools{};
         };
 
-        group_proxy(const sparse_set<Entity> &ref, std::tuple<pool_type<Get> *...> gpools)
+        group_proxy(const basic_sparse_set<Entity> &ref, std::tuple<pool_type<Get> *...> gpools)
             : handler{&ref},
               pools{gpools}
         {}
@@ -153,11 +153,11 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>> {
         }
 
     private:
-        const sparse_set<Entity> *handler;
+        const basic_sparse_set<Entity> *handler;
         std::tuple<pool_type<Get> *...> pools;
     };
 
-    basic_group(sparse_set<Entity> &ref, pool_type<Get> &... gpool) ENTT_NOEXCEPT
+    basic_group(basic_sparse_set<Entity> &ref, pool_type<Get> &... gpool) ENTT_NOEXCEPT
         : handler{&ref},
           pools{&gpool...}
     {}
@@ -179,9 +179,9 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Random access iterator type. */
-    using iterator = typename sparse_set<Entity>::iterator;
+    using iterator = typename basic_sparse_set<Entity>::iterator;
     /*! @brief Reversed iterator type. */
-    using reverse_iterator = typename sparse_set<Entity>::reverse_iterator;
+    using reverse_iterator = typename basic_sparse_set<Entity>::reverse_iterator;
 
     /**
      * @brief Returns the number of existing components of the given type.
@@ -547,7 +547,7 @@ public:
     }
 
 private:
-    sparse_set<entity_type> *handler;
+    basic_sparse_set<entity_type> *handler;
     const std::tuple<pool_type<Get> *...> pools;
 };
 
@@ -615,7 +615,7 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned...> {
         class proxy_iterator {
             friend class group_proxy;
 
-            using it_type = typename sparse_set<Entity>::iterator;
+            using it_type = typename basic_sparse_set<Entity>::iterator;
             using owned_type = decltype(std::tuple_cat(std::declval<std::conditional_t<is_eto_eligible_v<Owned>, std::tuple<>, std::tuple<component_iterator<Owned>>>>()...));
             using get_type = decltype(std::tuple_cat(std::declval<std::conditional_t<is_eto_eligible_v<Get>, std::tuple<>, std::tuple<pool_type<Get> *>>>()...));
 
@@ -681,7 +681,7 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned...> {
 
         [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
             return proxy_iterator{
-                std::get<0>(pools)->sparse_set<Entity>::end() - *length,
+                std::get<0>(pools)->basic_sparse_set<Entity>::end() - *length,
                 std::tuple_cat([length = *length](auto *cpool) {
                     if constexpr(is_eto_eligible_v<typename std::remove_reference_t<decltype(*cpool)>::object_type>) {
                         return std::make_tuple();
@@ -701,7 +701,7 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned...> {
 
         [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
             return proxy_iterator{
-                std::get<0>(pools)->sparse_set<Entity>::end(),
+                std::get<0>(pools)->basic_sparse_set<Entity>::end(),
                 std::tuple_cat([](auto *cpool) {
                     if constexpr(is_eto_eligible_v<typename std::remove_reference_t<decltype(*cpool)>::object_type>) {
                         return std::make_tuple();
@@ -732,7 +732,7 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned...> {
     template<typename Func, typename... Strong, typename... Weak>
     void traverse(Func func, type_list<Strong...>, type_list<Weak...>) const {
         [[maybe_unused]] auto it = std::make_tuple((std::get<pool_type<Strong> *>(pools)->end() - *length)...);
-        [[maybe_unused]] auto data = std::get<0>(pools)->sparse_set<entity_type>::end() - *length;
+        [[maybe_unused]] auto data = std::get<0>(pools)->basic_sparse_set<entity_type>::end() - *length;
 
         for(auto next = *length; next; --next) {
             if constexpr(std::is_invocable_v<Func, decltype(get<Strong>({}))..., decltype(get<Weak>({}))...>) {
@@ -755,9 +755,9 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Random access iterator type. */
-    using iterator = typename sparse_set<Entity>::iterator;
+    using iterator = typename basic_sparse_set<Entity>::iterator;
     /*! @brief Reversed iterator type. */
-    using reverse_iterator = typename sparse_set<Entity>::reverse_iterator;
+    using reverse_iterator = typename basic_sparse_set<Entity>::reverse_iterator;
 
     /**
      * @brief Returns the number of existing components of the given type.
@@ -864,7 +864,7 @@ public:
      * @return An iterator to the first entity of the group.
      */
     [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
-        return std::get<0>(pools)->sparse_set<entity_type>::end() - *length;
+        return std::get<0>(pools)->basic_sparse_set<entity_type>::end() - *length;
     }
 
     /**
@@ -882,7 +882,7 @@ public:
      * group.
      */
     [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
-        return std::get<0>(pools)->sparse_set<entity_type>::end();
+        return std::get<0>(pools)->basic_sparse_set<entity_type>::end();
     }
 
     /**
@@ -898,7 +898,7 @@ public:
      * @return An iterator to the first entity of the reversed group.
      */
     [[nodiscard]] reverse_iterator rbegin() const ENTT_NOEXCEPT {
-        return std::get<0>(pools)->sparse_set<entity_type>::rbegin();
+        return std::get<0>(pools)->basic_sparse_set<entity_type>::rbegin();
     }
 
     /**
@@ -917,7 +917,7 @@ public:
      * reversed group.
      */
     [[nodiscard]] reverse_iterator rend() const ENTT_NOEXCEPT {
-        return std::get<0>(pools)->sparse_set<entity_type>::rbegin() + *length;
+        return std::get<0>(pools)->basic_sparse_set<entity_type>::rbegin() + *length;
     }
 
     /**

src/entt/entity/observer.hpp

@@ -276,7 +276,7 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Random access iterator type. */
-    using iterator = typename sparse_set<Entity>::iterator;
+    using iterator = typename basic_sparse_set<Entity>::iterator;
 
     /*! @brief Default constructor. */
     basic_observer()
@@ -377,7 +377,7 @@ public:
      * @return An iterator to the first entity of the observer.
      */
     [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
-        return view.sparse_set<entity_type>::begin();
+        return view.basic_sparse_set<entity_type>::begin();
     }
 
     /**
@@ -391,7 +391,7 @@ public:
      * observer.
      */
     [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
-        return view.sparse_set<entity_type>::end();
+        return view.basic_sparse_set<entity_type>::end();
     }
 
     /*! @brief Clears the underlying container. */

src/entt/entity/registry.hpp

@@ -44,8 +44,8 @@ class basic_registry {
 
     struct pool_data {
         type_info info{};
-        std::unique_ptr<sparse_set<Entity>> pool{};
-        void(* erase)(sparse_set<Entity> &, basic_registry &, const Entity *, const Entity *);
+        std::unique_ptr<basic_sparse_set<Entity>> pool{};
+        void(* erase)(basic_sparse_set<Entity> &, basic_registry &, const Entity *, const Entity *);
     };
 
     template<typename...>
@@ -54,7 +54,7 @@ class basic_registry {
     template<typename... Exclude, typename... Get, typename... Owned>
     struct group_handler<exclude_t<Exclude...>, get_t<Get...>, Owned...> {
         static_assert(std::conjunction_v<std::is_same<Owned, std::decay_t<Owned>>..., std::is_same<Get, std::decay_t<Get>>..., std::is_same<Exclude, std::decay_t<Exclude>>...>, "One or more component types are invalid");
-        std::conditional_t<sizeof...(Owned) == 0, sparse_set<Entity>, std::size_t> current{};
+        std::conditional_t<sizeof...(Owned) == 0, basic_sparse_set<Entity>, std::size_t> current{};
 
         template<typename Component>
         void maybe_valid_if(basic_registry &owner, const Entity entt) {
@@ -114,7 +114,7 @@ class basic_registry {
         if(auto &&pdata = pools[index]; !pdata.pool) {
             pdata.info = type_id<Component>();
             pdata.pool.reset(new pool_t<Entity, Component>());
-            pdata.erase = +[](sparse_set<Entity> &cpool, basic_registry &owner, const Entity *first, const Entity *last) {
+            pdata.erase = +[](basic_sparse_set<Entity> &cpool, basic_registry &owner, const Entity *first, const Entity *last) {
                 static_cast<pool_t<Entity, Component> &>(cpool).erase(owner, first, last);
             };
         }
@@ -934,7 +934,7 @@ public:
             }
         } else {
             ([this](auto &&cpool) {
-                cpool.erase(*this, cpool.sparse_set<entity_type>::begin(), cpool.sparse_set<entity_type>::end());
+                cpool.erase(*this, cpool.basic_sparse_set<entity_type>::begin(), cpool.basic_sparse_set<entity_type>::end());
             }(assure<Component>()), ...);
         }
     }
@@ -1154,8 +1154,8 @@ public:
      */
     template<typename ItComp, typename ItExcl = id_type *>
     [[nodiscard]] basic_runtime_view<Entity> runtime_view(ItComp first, ItComp last, ItExcl from = {}, ItExcl to = {}) const {
-        std::vector<const sparse_set<Entity> *> component(std::distance(first, last));
-        std::vector<const sparse_set<Entity> *> filter(std::distance(from, to));
+        std::vector<const basic_sparse_set<Entity> *> component(std::distance(first, last));
+        std::vector<const basic_sparse_set<Entity> *> filter(std::distance(from, to));
 
         std::transform(first, last, component.begin(), [this](const auto ctype) {
             const auto it = std::find_if(pools.cbegin(), pools.cend(), [ctype](auto &&pdata) { return pdata.pool && pdata.info.hash() == ctype; });

src/entt/entity/runtime_view.hpp

@@ -58,12 +58,12 @@ class basic_runtime_view {
     /*! @brief A registry is allowed to create views. */
     friend class basic_registry<Entity>;
 
-    using underlying_iterator = typename sparse_set<Entity>::iterator;
+    using underlying_iterator = typename basic_sparse_set<Entity>::iterator;
 
     class view_iterator final {
         friend class basic_runtime_view<Entity>;
 
-        view_iterator(const std::vector<const sparse_set<Entity> *> &cpools, const std::vector<const sparse_set<Entity> *> &ignore, underlying_iterator curr) ENTT_NOEXCEPT
+        view_iterator(const std::vector<const basic_sparse_set<Entity> *> &cpools, const std::vector<const basic_sparse_set<Entity> *> &ignore, underlying_iterator curr) ENTT_NOEXCEPT
             : pools{&cpools},
               filter{&ignore},
               it{curr}
@@ -124,12 +124,12 @@ class basic_runtime_view {
         }
 
     private:
-        const std::vector<const sparse_set<Entity> *> *pools;
-        const std::vector<const sparse_set<Entity> *> *filter;
+        const std::vector<const basic_sparse_set<Entity> *> *pools;
+        const std::vector<const basic_sparse_set<Entity> *> *filter;
         underlying_iterator it;
     };
 
-    basic_runtime_view(std::vector<const sparse_set<Entity> *> cpools, std::vector<const sparse_set<Entity> *> epools) ENTT_NOEXCEPT
+    basic_runtime_view(std::vector<const basic_sparse_set<Entity> *> cpools, std::vector<const basic_sparse_set<Entity> *> epools) ENTT_NOEXCEPT
         : pools{std::move(cpools)},
           filter{std::move(epools)}
     {
@@ -239,8 +239,8 @@ public:
     }
 
 private:
-    std::vector<const sparse_set<Entity> *> pools;
-    std::vector<const sparse_set<Entity> *> filter;
+    std::vector<const basic_sparse_set<Entity> *> pools;
+    std::vector<const basic_sparse_set<Entity> *> filter;
 };
 
 

src/entt/entity/sparse_set.hpp

@@ -40,7 +40,7 @@ namespace entt {
  * @tparam Entity A valid entity type (see entt_traits for more details).
  */
 template<typename Entity>
-class sparse_set {
+class basic_sparse_set {
     static_assert(ENTT_PAGE_SIZE && ((ENTT_PAGE_SIZE & (ENTT_PAGE_SIZE - 1)) == 0), "ENTT_PAGE_SIZE must be a power of two");
     static constexpr auto entt_per_page = ENTT_PAGE_SIZE / sizeof(Entity);
 
@@ -48,7 +48,7 @@ class sparse_set {
     using page_type = std::unique_ptr<Entity[]>;
 
     class sparse_set_iterator final {
-        friend class sparse_set<Entity>;
+        friend class basic_sparse_set<Entity>;
 
         using packed_type = std::vector<Entity>;
         using index_type = typename traits_type::difference_type;
@@ -184,16 +184,16 @@ public:
     using reverse_iterator = const entity_type *;
 
     /*! @brief Default constructor. */
-    sparse_set() = default;
+    basic_sparse_set() = default;
 
     /*! @brief Default move constructor. */
-    sparse_set(sparse_set &&) = default;
+    basic_sparse_set(basic_sparse_set &&) = default;
 
     /*! @brief Default destructor. */
-    virtual ~sparse_set() = default;
+    virtual ~basic_sparse_set() = default;
 
     /*! @brief Default move assignment operator. @return This sparse set. */
-    sparse_set & operator=(sparse_set &&) = default;
+    basic_sparse_set & operator=(basic_sparse_set &&) = default;
 
     /**
      * @brief Increases the capacity of a sparse set.
@@ -576,7 +576,7 @@ public:
      *
      * @param other The sparse sets that imposes the order of the entities.
      */
-    void respect(const sparse_set &other) {
+    void respect(const basic_sparse_set &other) {
         const auto to = other.end();
         auto from = other.begin();
 

src/entt/entity/storage.hpp

@@ -46,10 +46,10 @@ namespace entt {
  * @tparam Type Type of objects assigned to the entities.
  */
 template<typename Entity, typename Type, typename = void>
-class storage: public sparse_set<Entity> {
+class storage: public basic_sparse_set<Entity> {
     static_assert(std::is_move_constructible_v<Type> && std::is_move_assignable_v<Type>, "The managed type must be at least move constructible and assignable");
 
-    using underlying_type = sparse_set<Entity>;
+    using underlying_type = basic_sparse_set<Entity>;
     using traits_type = entt_traits<Entity>;
 
     template<bool Const>
@@ -521,8 +521,8 @@ private:
 
 /*! @copydoc storage */
 template<typename Entity, typename Type>
-class storage<Entity, Type, std::enable_if_t<is_eto_eligible_v<Type>>>: public sparse_set<Entity> {
-    using underlying_type = sparse_set<Entity>;
+class storage<Entity, Type, std::enable_if_t<is_eto_eligible_v<Type>>>: public basic_sparse_set<Entity> {
+    using underlying_type = basic_sparse_set<Entity>;
 
 public:
     /*! @brief Type of the objects associated with the entities. */

src/entt/entity/view.hpp

@@ -74,8 +74,8 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> {
     template<typename Comp>
     using component_iterator = decltype(std::declval<pool_type<Comp>>().begin());
 
-    using unchecked_type = std::array<const sparse_set<Entity> *, (sizeof...(Component) - 1)>;
-    using filter_type = std::array<const sparse_set<Entity> *, sizeof...(Exclude)>;
+    using unchecked_type = std::array<const basic_sparse_set<Entity> *, (sizeof...(Component) - 1)>;
+    using filter_type = std::array<const basic_sparse_set<Entity> *, sizeof...(Exclude)>;
 
     template<typename It>
     class view_iterator final {
@@ -94,8 +94,8 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> {
         }
 
         [[nodiscard]] bool valid() const {
-            return std::all_of(unchecked.cbegin(), unchecked.cend(), [entt = *it](const sparse_set<Entity> *curr) { return curr->contains(entt); })
-                    && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt = *it](const sparse_set<Entity> *cpool) { return cpool->contains(entt); }));
+            return std::all_of(unchecked.cbegin(), unchecked.cend(), [entt = *it](const basic_sparse_set<Entity> *curr) { return curr->contains(entt); })
+                    && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt = *it](const basic_sparse_set<Entity> *cpool) { return cpool->contains(entt); }));
         }
 
     public:
@@ -154,7 +154,7 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> {
     class view_proxy {
         friend class basic_view<Entity, exclude_t<Exclude...>, Component...>;
 
-        using proxy_view_iterator = view_iterator<typename sparse_set<Entity>::iterator>;
+        using proxy_view_iterator = view_iterator<typename basic_sparse_set<Entity>::iterator>;
 
         class proxy_iterator {
             friend class view_proxy;
@@ -237,19 +237,19 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> {
         const std::tuple<pool_type<Component> *...> pools;
     };
 
-    basic_view(pool_type<Component> &... component, unpack_as_t<const sparse_set<Entity>, Exclude> &... epool) ENTT_NOEXCEPT
+    basic_view(pool_type<Component> &... component, unpack_as_t<const basic_sparse_set<Entity>, Exclude> &... epool) ENTT_NOEXCEPT
         : pools{&component...},
           view{candidate()},
           filter{&epool...}
     {}
 
-    [[nodiscard]] const sparse_set<Entity> * candidate() const ENTT_NOEXCEPT {
-        return (std::min)({ static_cast<const sparse_set<Entity> *>(std::get<pool_type<Component> *>(pools))... }, [](const auto *lhs, const auto *rhs) {
+    [[nodiscard]] const basic_sparse_set<Entity> * candidate() const ENTT_NOEXCEPT {
+        return (std::min)({ static_cast<const basic_sparse_set<Entity> *>(std::get<pool_type<Component> *>(pools))... }, [](const auto *lhs, const auto *rhs) {
             return lhs->size() < rhs->size();
         });
     }
 
-    [[nodiscard]] unchecked_type unchecked(const sparse_set<Entity> *cpool) const {
+    [[nodiscard]] unchecked_type unchecked(const basic_sparse_set<Entity> *cpool) const {
         std::size_t pos{};
         unchecked_type other{};
         ((std::get<pool_type<Component> *>(pools) == cpool ? nullptr : (other[pos] = std::get<pool_type<Component> *>(pools), other[pos++])), ...);
@@ -270,9 +270,9 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> {
         if constexpr(std::disjunction_v<std::is_same<Comp, Type>...>) {
             auto it = std::get<pool_type<Comp> *>(pools)->begin();
 
-            for(const auto entt: static_cast<const sparse_set<entity_type> &>(*std::get<pool_type<Comp> *>(pools))) {
+            for(const auto entt: static_cast<const basic_sparse_set<entity_type> &>(*std::get<pool_type<Comp> *>(pools))) {
                 if(((std::is_same_v<Comp, Component> || std::get<pool_type<Component> *>(pools)->contains(entt)) && ...)
-                        && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt](const sparse_set<Entity> *cpool) { return cpool->contains(entt); })))
+                        && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt](const basic_sparse_set<Entity> *cpool) { return cpool->contains(entt); })))
                 {
                     if constexpr(std::is_invocable_v<Func, decltype(get<Type>({}))...>) {
                         func(get<Comp, Type>(it, std::get<pool_type<Type> *>(pools), entt)...);
@@ -284,9 +284,9 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> {
                 ++it;
             }
         } else {
-            for(const auto entt: static_cast<const sparse_set<entity_type> &>(*std::get<pool_type<Comp> *>(pools))) {
+            for(const auto entt: static_cast<const basic_sparse_set<entity_type> &>(*std::get<pool_type<Comp> *>(pools))) {
                 if(((std::is_same_v<Comp, Component> || std::get<pool_type<Component> *>(pools)->contains(entt)) && ...)
-                        && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt](const sparse_set<Entity> *cpool) { return cpool->contains(entt); })))
+                        && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt](const basic_sparse_set<Entity> *cpool) { return cpool->contains(entt); })))
                 {
                     if constexpr(std::is_invocable_v<Func, decltype(get<Type>({}))...>) {
                         func(std::get<pool_type<Type> *>(pools)->get(entt)...);
@@ -305,7 +305,7 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> {
 
         while(first != last) {
             if((std::get<pool_type<Component> *>(pools)->contains(*first) && ...)
-                    && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt = *first](const sparse_set<Entity> *cpool) { return cpool->contains(entt); })))
+                    && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt = *first](const basic_sparse_set<Entity> *cpool) { return cpool->contains(entt); })))
             {
                 const auto base = *(first++);
                 const auto chunk = (std::min)({ (std::get<pool_type<Component> *>(pools)->size() - std::get<pool_type<Component> *>(pools)->index(base))... });
@@ -314,7 +314,7 @@ class basic_view<Entity, exclude_t<Exclude...>, Component...> {
                 for(++length;
                     length < chunk
                         && ((*(std::get<pool_type<Component> *>(pools)->data() + std::get<pool_type<Component> *>(pools)->index(base) + length) == *first) && ...)
-                        && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt = *first](const sparse_set<Entity> *cpool) { return cpool->contains(entt); }));
+                        && (sizeof...(Exclude) == 0 || std::none_of(filter.cbegin(), filter.cend(), [entt = *first](const basic_sparse_set<Entity> *cpool) { return cpool->contains(entt); }));
                     ++length, ++first);
 
                 func(view->data() + view->index(base), (std::get<pool_type<Type> *>(pools)->raw() + std::get<pool_type<Type> *>(pools)->index(base))..., length);
@@ -330,9 +330,9 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Bidirectional iterator type. */
-    using iterator = view_iterator<typename sparse_set<entity_type>::iterator>;
+    using iterator = view_iterator<typename basic_sparse_set<entity_type>::iterator>;
     /*! @brief Reverse iterator type. */
-    using reverse_iterator = view_iterator<typename sparse_set<entity_type>::reverse_iterator>;
+    using reverse_iterator = view_iterator<typename basic_sparse_set<entity_type>::reverse_iterator>;
 
     /**
      * @brief Estimates the number of entities iterated by the view.
@@ -566,7 +566,7 @@ public:
      */
     template<typename Comp>
     [[nodiscard]] auto proxy() const ENTT_NOEXCEPT {
-        const sparse_set<entity_type> *cpool = std::get<pool_type<Comp> *>(pools);
+        const basic_sparse_set<entity_type> *cpool = std::get<pool_type<Comp> *>(pools);
         iterator first{cpool->begin(), cpool->end(), cpool->begin(), unchecked(cpool), filter};
         iterator last{cpool->begin(), cpool->end(), cpool->end(), unchecked(cpool), filter};
         return view_proxy{std::move(first), std::move(last), pools};
@@ -613,7 +613,7 @@ public:
 
 private:
     const std::tuple<pool_type<Component> *...> pools;
-    mutable const sparse_set<entity_type>* view;
+    mutable const basic_sparse_set<entity_type>* view;
     filter_type filter;
 };
 
@@ -664,8 +664,8 @@ class basic_view<Entity, exclude_t<>, Component> {
 
             using it_type = std::conditional_t<
                 is_eto_eligible_v<Component>,
-                std::tuple<typename sparse_set<Entity>::iterator>,
-                std::tuple<typename sparse_set<Entity>::iterator, decltype(std::declval<pool_type>().begin())>
+                std::tuple<typename basic_sparse_set<Entity>::iterator>,
+                std::tuple<typename basic_sparse_set<Entity>::iterator, decltype(std::declval<pool_type>().begin())>
             >;
 
             proxy_iterator(it_type from) ENTT_NOEXCEPT
@@ -713,17 +713,17 @@ class basic_view<Entity, exclude_t<>, Component> {
 
         [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
             if constexpr(is_eto_eligible_v<Component>) {
-                return proxy_iterator{std::make_tuple(pool->sparse_set<entity_type>::begin())};
+                return proxy_iterator{std::make_tuple(pool->basic_sparse_set<entity_type>::begin())};
             } else {
-                return proxy_iterator{std::make_tuple(pool->sparse_set<entity_type>::begin(), pool->begin())};
+                return proxy_iterator{std::make_tuple(pool->basic_sparse_set<entity_type>::begin(), pool->begin())};
             }
         }
 
         [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
             if constexpr(is_eto_eligible_v<Component>) {
-                return proxy_iterator{std::make_tuple(pool->sparse_set<entity_type>::end())};
+                return proxy_iterator{std::make_tuple(pool->basic_sparse_set<entity_type>::end())};
             } else {
-                return proxy_iterator{std::make_tuple(pool->sparse_set<entity_type>::end(), pool->end())};
+                return proxy_iterator{std::make_tuple(pool->basic_sparse_set<entity_type>::end(), pool->end())};
             }
         }
 
@@ -743,9 +743,9 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Random access iterator type. */
-    using iterator = typename sparse_set<Entity>::iterator;
+    using iterator = typename basic_sparse_set<Entity>::iterator;
     /*! @brief Reversed iterator type. */
-    using reverse_iterator = typename sparse_set<Entity>::reverse_iterator;
+    using reverse_iterator = typename basic_sparse_set<Entity>::reverse_iterator;
 
     /**
      * @brief Returns the number of entities that have the given component.
@@ -808,7 +808,7 @@ public:
      * @return An iterator to the first entity of the view.
      */
     [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
-        return pool->sparse_set<Entity>::begin();
+        return pool->basic_sparse_set<Entity>::begin();
     }
 
     /**
@@ -825,7 +825,7 @@ public:
      * @return An iterator to the entity following the last entity of the view.
      */
     [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
-        return pool->sparse_set<Entity>::end();
+        return pool->basic_sparse_set<Entity>::end();
     }
 
     /**
@@ -841,7 +841,7 @@ public:
      * @return An iterator to the first entity of the reversed view.
      */
     [[nodiscard]] reverse_iterator rbegin() const ENTT_NOEXCEPT {
-        return pool->sparse_set<Entity>::rbegin();
+        return pool->basic_sparse_set<Entity>::rbegin();
     }
 
     /**
@@ -860,7 +860,7 @@ public:
      * reversed view.
      */
     [[nodiscard]] reverse_iterator rend() const ENTT_NOEXCEPT {
-        return pool->sparse_set<Entity>::rend();
+        return pool->basic_sparse_set<Entity>::rend();
     }
 
     /**

test/entt/entity/sparse_set.cpp

@@ -12,7 +12,7 @@ struct empty_type {};
 struct boxed_int { int value; };
 
 TEST(SparseSet, Functionalities) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
 
     set.reserve(42);
 
@@ -53,7 +53,7 @@ TEST(SparseSet, Functionalities) {
     ASSERT_TRUE(std::is_move_constructible_v<decltype(set)>);
     ASSERT_TRUE(std::is_move_assignable_v<decltype(set)>);
 
-    entt::sparse_set<entt::entity> other{std::move(set)};
+    entt::sparse_set other{std::move(set)};
 
     set = std::move(other);
     other = std::move(set);
@@ -73,7 +73,7 @@ TEST(SparseSet, Functionalities) {
 }
 
 TEST(SparseSet, Pagination) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     constexpr auto entt_per_page = ENTT_PAGE_SIZE / sizeof(entt::entity);
 
     ASSERT_EQ(set.extent(), 0u);
@@ -109,7 +109,7 @@ TEST(SparseSet, Pagination) {
 }
 
 TEST(SparseSet, BatchAdd) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     entt::entity entities[2];
 
     entities[0] = entt::entity{3};
@@ -139,9 +139,9 @@ TEST(SparseSet, BatchAdd) {
 }
 
 TEST(SparseSet, Iterator) {
-    using iterator = typename entt::sparse_set<entt::entity>::iterator;
+    using iterator = typename entt::sparse_set::iterator;
 
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     set.emplace(entt::entity{3});
 
     iterator end{set.begin()};
@@ -184,9 +184,9 @@ TEST(SparseSet, Iterator) {
 }
 
 TEST(SparseSet, ReverseIterator) {
-    using reverse_iterator = typename entt::sparse_set<entt::entity>::reverse_iterator;
+    using reverse_iterator = typename entt::sparse_set::reverse_iterator;
 
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     set.emplace(entt::entity{3});
 
     reverse_iterator end{set.rbegin()};
@@ -228,7 +228,7 @@ TEST(SparseSet, ReverseIterator) {
 }
 
 TEST(SparseSet, Find) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     set.emplace(entt::entity{3});
     set.emplace(entt::entity{42});
     set.emplace(entt::entity{99});
@@ -248,7 +248,7 @@ TEST(SparseSet, Find) {
 }
 
 TEST(SparseSet, Data) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
 
     set.emplace(entt::entity{3});
     set.emplace(entt::entity{12});
@@ -264,7 +264,7 @@ TEST(SparseSet, Data) {
 }
 
 TEST(SparseSet, SortOrdered) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
 
     set.emplace(entt::entity{42});
     set.emplace(entt::entity{12});
@@ -304,7 +304,7 @@ TEST(SparseSet, SortOrdered) {
 }
 
 TEST(SparseSet, SortReverse) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
 
     set.emplace(entt::entity{3});
     set.emplace(entt::entity{7});
@@ -344,7 +344,7 @@ TEST(SparseSet, SortReverse) {
 }
 
 TEST(SparseSet, SortUnordered) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
 
     set.emplace(entt::entity{9});
     set.emplace(entt::entity{7});
@@ -384,7 +384,7 @@ TEST(SparseSet, SortUnordered) {
 }
 
 TEST(SparseSet, SortRange) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
 
     set.emplace(entt::entity{9});
     set.emplace(entt::entity{7});
@@ -448,7 +448,7 @@ TEST(SparseSet, SortRange) {
 }
 
 TEST(SparseSet, ArrangOrdered) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     entt::entity entities[5]{entt::entity{42}, entt::entity{12}, entt::entity{9}, entt::entity{7}, entt::entity{3}};
     set.insert(std::begin(entities), std::end(entities));
 
@@ -470,7 +470,7 @@ TEST(SparseSet, ArrangOrdered) {
 }
 
 TEST(SparseSet, ArrangeReverse) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     entt::entity entities[5]{entt::entity{3}, entt::entity{7}, entt::entity{9}, entt::entity{12}, entt::entity{42}};
     set.insert(std::begin(entities), std::end(entities));
 
@@ -494,7 +494,7 @@ TEST(SparseSet, ArrangeReverse) {
 }
 
 TEST(SparseSet, ArrangeUnordered) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     entt::entity entities[5]{entt::entity{9}, entt::entity{7}, entt::entity{3}, entt::entity{12}, entt::entity{42}};
     set.insert(std::begin(entities), std::end(entities));
 
@@ -518,7 +518,7 @@ TEST(SparseSet, ArrangeUnordered) {
 }
 
 TEST(SparseSet, ArrangeRange) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     entt::entity entities[5]{entt::entity{9}, entt::entity{7}, entt::entity{3}, entt::entity{12}, entt::entity{42}};
     set.insert(std::begin(entities), std::end(entities));
 
@@ -564,7 +564,7 @@ TEST(SparseSet, ArrangeRange) {
 }
 
 TEST(SparseSet, ArrangeCornerCase) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     entt::entity entities[5]{entt::entity{0}, entt::entity{1}, entt::entity{4}, entt::entity{3}, entt::entity{2}};
     set.insert(std::begin(entities), std::end(entities));
 
@@ -586,8 +586,8 @@ TEST(SparseSet, ArrangeCornerCase) {
 }
 
 TEST(SparseSet, RespectDisjoint) {
-    entt::sparse_set<entt::entity> lhs;
-    entt::sparse_set<entt::entity> rhs;
+    entt::sparse_set lhs;
+    entt::sparse_set rhs;
 
     lhs.emplace(entt::entity{3});
     lhs.emplace(entt::entity{12});
@@ -605,8 +605,8 @@ TEST(SparseSet, RespectDisjoint) {
 }
 
 TEST(SparseSet, RespectOverlap) {
-    entt::sparse_set<entt::entity> lhs;
-    entt::sparse_set<entt::entity> rhs;
+    entt::sparse_set lhs;
+    entt::sparse_set rhs;
 
     lhs.emplace(entt::entity{3});
     lhs.emplace(entt::entity{12});
@@ -626,8 +626,8 @@ TEST(SparseSet, RespectOverlap) {
 }
 
 TEST(SparseSet, RespectOrdered) {
-    entt::sparse_set<entt::entity> lhs;
-    entt::sparse_set<entt::entity> rhs;
+    entt::sparse_set lhs;
+    entt::sparse_set rhs;
 
     lhs.emplace(entt::entity{1});
     lhs.emplace(entt::entity{2});
@@ -666,8 +666,8 @@ TEST(SparseSet, RespectOrdered) {
 }
 
 TEST(SparseSet, RespectReverse) {
-    entt::sparse_set<entt::entity> lhs;
-    entt::sparse_set<entt::entity> rhs;
+    entt::sparse_set lhs;
+    entt::sparse_set rhs;
 
     lhs.emplace(entt::entity{1});
     lhs.emplace(entt::entity{2});
@@ -706,8 +706,8 @@ TEST(SparseSet, RespectReverse) {
 }
 
 TEST(SparseSet, RespectUnordered) {
-    entt::sparse_set<entt::entity> lhs;
-    entt::sparse_set<entt::entity> rhs;
+    entt::sparse_set lhs;
+    entt::sparse_set rhs;
 
     lhs.emplace(entt::entity{1});
     lhs.emplace(entt::entity{2});
@@ -746,7 +746,7 @@ TEST(SparseSet, RespectUnordered) {
 }
 
 TEST(SparseSet, CanModifyDuringIteration) {
-    entt::sparse_set<entt::entity> set;
+    entt::sparse_set set;
     set.emplace(entt::entity{0});
 
     ASSERT_EQ(set.capacity(), 1u);