From a554d406e7e5364a9d7515f35dc50da33d2f3aea Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Wed, 23 Nov 2022 11:06:51 +0100 Subject: [PATCH] registry: * public traits_type member type * break dependency on component_traits * use public storage traits_type member type --- src/entt/entity/registry.hpp | 50 ++++++++++++++++++------------------ 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/src/entt/entity/registry.hpp b/src/entt/entity/registry.hpp index 3eda5a265..63fd64ad0 100644 --- a/src/entt/entity/registry.hpp +++ b/src/entt/entity/registry.hpp @@ -20,7 +20,6 @@ #include "../core/type_info.hpp" #include "../core/type_traits.hpp" #include "../core/utility.hpp" -#include "component.hpp" #include "entity.hpp" #include "fwd.hpp" #include "group.hpp" @@ -241,7 +240,6 @@ class basic_registry { using alloc_traits = typename std::allocator_traits; static_assert(std::is_same_v, "Invalid value type"); using basic_common_type = basic_sparse_set; - using entity_traits = entt_traits; template using storage_for_type = typename storage_for>>::type; @@ -252,7 +250,7 @@ class basic_registry { template struct group_handler, get_t, Owned...> { // nasty workaround for an issue with the toolset v141 that doesn't accept a fold expression here - static_assert(!std::disjunction_v::in_place_delete>...>, "Groups do not support in-place delete"); + static_assert(!std::disjunction_v::traits_type::in_place_delete>...>, "Groups do not support in-place delete"); using value_type = std::conditional_t; value_type current{}; @@ -328,21 +326,21 @@ class basic_registry { } auto generate_identifier(const std::size_t pos) noexcept { - ENTT_ASSERT(pos < entity_traits::to_entity(null), "No entities available"); - return entity_traits::combine(static_cast(pos), {}); + ENTT_ASSERT(pos < traits_type::to_entity(null), "No entities available"); + return traits_type::combine(static_cast(pos), {}); } auto recycle_identifier() noexcept { ENTT_ASSERT(free_list != null, "No entities available"); - const auto curr = entity_traits::to_entity(free_list); - free_list = entity_traits::combine(entity_traits::to_integral(epool[curr]), tombstone); - return (epool[curr] = entity_traits::combine(curr, entity_traits::to_integral(epool[curr]))); + const auto curr = traits_type::to_entity(free_list); + free_list = traits_type::combine(traits_type::to_integral(epool[curr]), tombstone); + return (epool[curr] = traits_type::combine(curr, traits_type::to_integral(epool[curr]))); } - auto release_entity(const Entity entt, const typename entity_traits::version_type version) { - const typename entity_traits::version_type vers = version + (version == entity_traits::to_version(tombstone)); - epool[entity_traits::to_entity(entt)] = entity_traits::construct(entity_traits::to_integral(free_list), vers); - free_list = entity_traits::combine(entity_traits::to_integral(entt), tombstone); + auto release_entity(const Entity entt, const typename entt_traits::version_type version) { + const typename traits_type::version_type vers = version + (version == traits_type::to_version(tombstone)); + epool[traits_type::to_entity(entt)] = traits_type::construct(traits_type::to_integral(free_list), vers); + free_list = traits_type::combine(traits_type::to_integral(entt), tombstone); return vers; } @@ -353,12 +351,14 @@ class basic_registry { } public: + /*! @brief Entity traits. */ + using traits_type = entt_traits; /*! @brief Allocator type. */ using allocator_type = Allocator; /*! @brief Underlying entity identifier. */ using entity_type = Entity; /*! @brief Underlying version type. */ - using version_type = typename entity_traits::version_type; + using version_type = typename traits_type::version_type; /*! @brief Unsigned integer type. */ using size_type = std::size_t; /*! @brief Common type among all storage types. */ @@ -528,7 +528,7 @@ public: auto sz = epool.size(); for(auto curr = free_list; curr != null; --sz) { - curr = epool[entity_traits::to_entity(curr)]; + curr = epool[traits_type::to_entity(curr)]; } return sz; @@ -593,7 +593,7 @@ public: * @return True if the identifier is valid, false otherwise. */ [[nodiscard]] bool valid(const entity_type entt) const { - const auto pos = size_type(entity_traits::to_entity(entt)); + const auto pos = size_type(traits_type::to_entity(entt)); return (pos < epool.size() && epool[pos] == entt); } @@ -604,8 +604,8 @@ public: * version otherwise. */ [[nodiscard]] version_type current(const entity_type entt) const { - const auto pos = size_type(entity_traits::to_entity(entt)); - return entity_traits::to_version(pos < epool.size() ? epool[pos] : tombstone); + const auto pos = size_type(traits_type::to_entity(entt)); + return traits_type::to_version(pos < epool.size() ? epool[pos] : tombstone); } /** @@ -630,7 +630,7 @@ public: if(hint == null || hint == tombstone) { return create(); - } else if(const auto req = entity_traits::to_entity(hint); !(req < length)) { + } else if(const auto req = traits_type::to_entity(hint); !(req < length)) { epool.resize(size_type(req) + 1u, null); for(auto pos = length; pos < req; ++pos) { @@ -638,12 +638,12 @@ public: } return (epool[req] = hint); - } else if(const auto curr = entity_traits::to_entity(epool[req]); req == curr) { + } else if(const auto curr = traits_type::to_entity(epool[req]); req == curr) { return create(); } else { auto *it = &free_list; - for(; entity_traits::to_entity(*it) != req; it = &epool[entity_traits::to_entity(*it)]) {} - *it = entity_traits::combine(curr, entity_traits::to_integral(*it)); + for(; traits_type::to_entity(*it) != req; it = &epool[traits_type::to_entity(*it)]) {} + *it = traits_type::combine(curr, traits_type::to_integral(*it)); return (epool[req] = hint); } } @@ -707,7 +707,7 @@ public: * @return The version of the recycled entity. */ version_type release(const entity_type entt) { - return release(entt, static_cast(entity_traits::to_version(entt) + 1u)); + return release(entt, static_cast(traits_type::to_version(entt) + 1u)); } /** @@ -724,7 +724,7 @@ public: */ version_type release(const entity_type entt, const version_type version) { ENTT_ASSERT(valid(entt), "Invalid identifier"); - ENTT_ASSERT(std::all_of(pools.cbegin(), pools.cend(), [entt](auto &&curr) { return (curr.second->current(entt) == entity_traits::to_version(tombstone)); }), "Non-orphan entity"); + ENTT_ASSERT(std::all_of(pools.cbegin(), pools.cend(), [entt](auto &&curr) { return (curr.second->current(entt) == traits_type::to_version(tombstone)); }), "Non-orphan entity"); return release_entity(entt, version); } @@ -758,7 +758,7 @@ public: * @return The version of the recycled entity. */ version_type destroy(const entity_type entt) { - return destroy(entt, static_cast(entity_traits::to_version(entt) + 1u)); + return destroy(entt, static_cast(traits_type::to_version(entt) + 1u)); } /** @@ -1160,7 +1160,7 @@ public: } } else { for(auto pos = epool.size(); pos; --pos) { - if(const auto entity = epool[pos - 1]; entity_traits::to_entity(entity) == (pos - 1)) { + if(const auto entity = epool[pos - 1]; traits_type::to_entity(entity) == (pos - 1)) { func(entity); } }