From b2d0e7fae2b8f4779c58a51f5ef2770d3d7bc96f Mon Sep 17 00:00:00 2001 From: Michele Caini Date: Wed, 25 Dec 2019 18:09:49 +0100 Subject: [PATCH] registry: assure returns a reference now --- TODO | 2 +- src/entt/entity/group.hpp | 18 ++--- src/entt/entity/registry.hpp | 142 +++++++++++++++++------------------ src/entt/entity/view.hpp | 12 +-- 4 files changed, 87 insertions(+), 87 deletions(-) diff --git a/TODO b/TODO index c3aa220e2..719cf1db4 100644 --- a/TODO +++ b/TODO @@ -23,5 +23,5 @@ * review and suppress warnings, if any * extract only the type within type_info, hash its name (more portable) * registry - - ::assure -> pool_type & + - ::get -> use std::forward/forward_as_tuple and remove one of them (also try_get and the others) - ::group improve, reduce code diff --git a/src/entt/entity/group.hpp b/src/entt/entity/group.hpp index 3fe572a9d..d83d1d985 100644 --- a/src/entt/entity/group.hpp +++ b/src/entt/entity/group.hpp @@ -73,10 +73,10 @@ class basic_group, get_t> { template using pool_type = std::conditional_t, const storage>, storage>; - // we could use pool_type *..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug) - basic_group(sparse_set *ref, storage> *... gpool) ENTT_NOEXCEPT - : handler{ref}, - pools{gpool...} + // we could use pool_type &..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug) + basic_group(sparse_set &ref, storage> &... gpool) ENTT_NOEXCEPT + : handler{&ref}, + pools{&gpool...} {} template @@ -490,11 +490,11 @@ class basic_group, get_t, Owned...> { template using component_iterator_type = decltype(std::declval>().begin()); - // we could use pool_type *..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug) - basic_group(const std::size_t *ref, const std::size_t *extent, storage> *... opool, storage> *... gpool) ENTT_NOEXCEPT - : pools{opool..., gpool...}, - length{extent}, - super{ref} + // we could use pool_type &..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug) + basic_group(const std::size_t &ref, const std::size_t &extent, storage> &... opool, storage> &... gpool) ENTT_NOEXCEPT + : pools{&opool..., &gpool...}, + length{&extent}, + super{&ref} {} template diff --git a/src/entt/entity/registry.hpp b/src/entt/entity/registry.hpp index 3271dbbbf..3f921eb27 100644 --- a/src/entt/entity/registry.hpp +++ b/src/entt/entity/registry.hpp @@ -111,23 +111,23 @@ class basic_registry { template struct group_handler, get_t, Owned...> { - const std::tuple *..., pool_type *..., pool_type *...> cpools{}; + const std::tuple &..., pool_type &..., pool_type &...> cpools{}; std::conditional_t, std::size_t> owned{}; template void maybe_valid_if(const Entity entt) { - const auto is_valid = ((std::is_same_v || std::get *>(cpools)->has(entt)) && ...) - && ((std::is_same_v || std::get *>(cpools)->has(entt)) && ...) - && ((std::is_same_v || !std::get *>(cpools)->has(entt)) && ...); + const auto is_valid = ((std::is_same_v || std::get &>(cpools).has(entt)) && ...) + && ((std::is_same_v || std::get &>(cpools).has(entt)) && ...) + && ((std::is_same_v || !std::get &>(cpools).has(entt)) && ...); if constexpr(sizeof...(Owned) == 0) { if(is_valid && !owned.has(entt)) { owned.construct(entt); } } else { - if(is_valid && !(std::get<0>(cpools)->index(entt) < owned)) { + if(is_valid && !(std::get<0>(cpools).index(entt) < owned)) { const auto pos = owned++; - (std::get *>(cpools)->swap(std::get *>(cpools)->data()[pos], entt), ...); + (std::get &>(cpools).swap(std::get &>(cpools).data()[pos], entt), ...); } } } @@ -138,9 +138,9 @@ class basic_registry { owned.destroy(entt); } } else { - if(std::get<0>(cpools)->has(entt) && std::get<0>(cpools)->index(entt) < owned) { + if(std::get<0>(cpools).has(entt) && std::get<0>(cpools).index(entt) < owned) { const auto pos = --owned; - (std::get *>(cpools)->swap(std::get *>(cpools)->data()[pos], entt), ...); + (std::get &>(cpools).swap(std::get &>(cpools).data()[pos], entt), ...); } } } @@ -209,7 +209,7 @@ class basic_registry { } template - const pool_type * assure(Args &&... args) const { + const pool_type & assure(Args &&... args) const { static_assert(std::is_same_v>); static std::size_t index{pools.size()}; @@ -240,12 +240,12 @@ class basic_registry { } } - return static_cast *>(pools[index].pool.get()); + return static_cast &>(*pools[index].pool); } template - pool_type * assure() { - return const_cast *>(std::as_const(*this).template assure()); + pool_type & assure() { + return const_cast &>(std::as_const(*this).template assure()); } public: @@ -295,7 +295,7 @@ public: */ template size_type size() const { - return assure()->size(); + return assure().size(); } /** @@ -339,7 +339,7 @@ public: if constexpr(sizeof...(Component) == 0) { entities.reserve(cap); } else { - (assure()->reserve(cap), ...); + (assure().reserve(cap), ...); } } @@ -350,7 +350,7 @@ public: */ template size_type capacity() const { - return assure()->capacity(); + return assure().capacity(); } /** @@ -369,7 +369,7 @@ public: */ template void shrink_to_fit() { - (assure()->shrink_to_fit(), ...); + (assure().shrink_to_fit(), ...); } /** @@ -388,7 +388,7 @@ public: if constexpr(sizeof...(Component) == 0) { return !alive(); } else { - return (assure()->empty() && ...); + return (assure().empty() && ...); } } @@ -411,7 +411,7 @@ public: */ template const Component * raw() const { - return assure()->raw(); + return assure().raw(); } /*! @copydoc raw */ @@ -435,7 +435,7 @@ public: */ template const entity_type * data() const { - return assure()->data(); + return assure().data(); } /** @@ -538,7 +538,7 @@ public: std::generate(first, last, [this]() { return generate(); }); if constexpr(sizeof...(Component) > 0) { - return std::make_tuple(assure()->assign(*this, first, last)...); + return std::make_tuple(assure().assign(*this, first, last)...); } } @@ -616,7 +616,7 @@ public: template decltype(auto) assign(const entity_type entity, Args &&... args) { ENTT_ASSERT(valid(entity)); - return assure()->assign(*this, entity, std::forward(args)...); + return assure().assign(*this, entity, std::forward(args)...); } /** @@ -636,7 +636,7 @@ public: std::enable_if_t::value_type, entity_type>, typename pool_type::reverse_iterator_type> assign(It first, It last, Args &&... args) { ENTT_ASSERT(std::all_of(first, last, [this](const auto entity) { return valid(entity); })); - return assure()->assign(*this, first, last, std::forward(args)...); + return assure().assign(*this, first, last, std::forward(args)...); } /** @@ -655,7 +655,7 @@ public: template void remove(const entity_type entity) { ENTT_ASSERT(valid(entity)); - (assure()->remove(*this, entity), ...); + (assure().remove(*this, entity), ...); } /** @@ -690,7 +690,7 @@ public: template bool has(const entity_type entity) const { ENTT_ASSERT(valid(entity)); - return (assure()->has(entity) && ...); + return (assure().has(entity) && ...); } /** @@ -712,7 +712,7 @@ public: ENTT_ASSERT(valid(entity)); if constexpr(sizeof...(Component) == 1) { - return (assure()->get(entity), ...); + return (assure().get(entity), ...); } else { return std::tuple({}))...>{get(entity)...}; } @@ -724,7 +724,7 @@ public: ENTT_ASSERT(valid(entity)); if constexpr(sizeof...(Component) == 1) { - return (assure()->get(entity), ...); + return (assure().get(entity), ...); } else { return std::tuple({}))...>{get(entity)...}; } @@ -757,8 +757,8 @@ public: template decltype(auto) get_or_assign(const entity_type entity, Args &&... args) { ENTT_ASSERT(valid(entity)); - auto *cpool = assure(); - return cpool->has(entity) ? cpool->get(entity) : cpool->assign(*this, entity, std::forward(args)...); + auto &cpool = assure(); + return cpool.has(entity) ? cpool.get(entity) : cpool.assign(*this, entity, std::forward(args)...); } /** @@ -778,7 +778,7 @@ public: ENTT_ASSERT(valid(entity)); if constexpr(sizeof...(Component) == 1) { - return (assure()->try_get(entity), ...); + return (assure().try_get(entity), ...); } else { return std::tuple({}))...>{try_get(entity)...}; } @@ -788,7 +788,7 @@ public: template auto try_get([[maybe_unused]] const entity_type entity) { if constexpr(sizeof...(Component) == 1) { - return (assure()->try_get(entity), ...); + return (assure().try_get(entity), ...); } else { return std::tuple({}))...>{try_get(entity)...}; } @@ -817,7 +817,7 @@ public: template decltype(auto) replace(const entity_type entity, Args &&... args) { ENTT_ASSERT(valid(entity)); - return assure()->replace(*this, entity, std::forward(args)...); + return assure().replace(*this, entity, std::forward(args)...); } /** @@ -845,8 +845,8 @@ public: template decltype(auto) assign_or_replace(const entity_type entity, Args &&... args) { ENTT_ASSERT(valid(entity)); - auto *cpool = assure(); - return cpool->has(entity) ? cpool->replace(*this, entity, std::forward(args)...) : cpool->assign(*this, entity, std::forward(args)...); + auto &cpool = assure(); + return cpool.has(entity) ? cpool.replace(*this, entity, std::forward(args)...) : cpool.assign(*this, entity, std::forward(args)...); } /** @@ -867,8 +867,8 @@ public: void reset(const entity_type entity) { ENTT_ASSERT(valid(entity)); - if(auto *cpool = assure(); cpool->has(entity)) { - cpool->remove(*this, entity); + if(auto &cpool = assure(); cpool.has(entity)) { + cpool.remove(*this, entity); } } @@ -882,12 +882,12 @@ public: */ template void reset() { - if(auto *cpool = assure(); cpool->on_destroy().empty()) { + if(auto &cpool = assure(); cpool.on_destroy().empty()) { // no group set, otherwise the signal wouldn't be empty - cpool->reset(); + cpool.reset(); } else { - for(const auto entity: static_cast &>(*cpool)) { - cpool->remove(*this, entity); + for(const auto entity: static_cast &>(cpool)) { + cpool.remove(*this, entity); } } } @@ -1017,7 +1017,7 @@ public: */ template auto on_construct() { - return assure()->on_construct(); + return assure().on_construct(); } /** @@ -1048,7 +1048,7 @@ public: */ template auto on_replace() { - return assure()->on_replace(); + return assure().on_replace(); } /** @@ -1080,7 +1080,7 @@ public: */ template auto on_destroy() { - return assure()->on_destroy(); + return assure().on_destroy(); } /** @@ -1132,9 +1132,9 @@ public: */ template void sort(Compare compare, Sort algo = Sort{}, Args &&... args) { - auto *cpool = assure(); - ENTT_ASSERT(!cpool->super); - cpool->sort(cpool->begin(), cpool->end(), std::move(compare), std::move(algo), std::forward(args)...); + auto &cpool = assure(); + ENTT_ASSERT(!cpool.super); + cpool.sort(cpool.begin(), cpool.end(), std::move(compare), std::move(algo), std::forward(args)...); } /** @@ -1174,9 +1174,9 @@ public: */ template void sort() { - auto *cpool = assure(); - ENTT_ASSERT(!cpool->super); - cpool->respect(*assure()); + auto &cpool = assure(); + ENTT_ASSERT(!cpool.super); + cpool.respect(assure()); } /** @@ -1232,7 +1232,7 @@ public: */ template bool sortable() const { - return !(assure()->super || ...); + return !(assure().super || ...); } /** @@ -1270,7 +1270,7 @@ public: using handler_type = group_handler, get_t, Owned...>; [[maybe_unused]] constexpr auto size = sizeof...(Owned) + sizeof...(Get) + sizeof...(Exclude); - const auto cpools = std::make_tuple(assure>()..., assure>()..., assure()...); + const auto cpools = std::forward_as_tuple(assure>()..., assure>()..., assure()...); const std::size_t extent[3]{sizeof...(Owned), sizeof...(Get), sizeof...(Exclude)}; handler_type *handler = nullptr; @@ -1323,35 +1323,35 @@ public: handler = static_cast(groups.insert(next, std::move(gdata))->group.get()); } - ((std::get *>(cpools)->super = std::max(std::get *>(cpools)->super, size)), ...); + ((std::get &>(cpools).super = std::max(std::get &>(cpools).super, size)), ...); - (std::get *>(cpools)->on_construct().before(maybe_valid_if).template connect<&handler_type::template maybe_valid_if>(*handler), ...); - (std::get *>(cpools)->on_construct().before(maybe_valid_if).template connect<&handler_type::template maybe_valid_if>(*handler), ...); - (std::get *>(cpools)->on_destroy().before(maybe_valid_if).template connect<&handler_type::template maybe_valid_if>(*handler), ...); + (std::get &>(cpools).on_construct().before(maybe_valid_if).template connect<&handler_type::template maybe_valid_if>(*handler), ...); + (std::get &>(cpools).on_construct().before(maybe_valid_if).template connect<&handler_type::template maybe_valid_if>(*handler), ...); + (std::get &>(cpools).on_destroy().before(maybe_valid_if).template connect<&handler_type::template maybe_valid_if>(*handler), ...); - (std::get *>(cpools)->on_destroy().before(discard_if).template connect<&handler_type::discard_if>(*handler), ...); - (std::get *>(cpools)->on_destroy().before(discard_if).template connect<&handler_type::discard_if>(*handler), ...); - (std::get *>(cpools)->on_construct().before(discard_if).template connect<&handler_type::discard_if>(*handler), ...); + (std::get &>(cpools).on_destroy().before(discard_if).template connect<&handler_type::discard_if>(*handler), ...); + (std::get &>(cpools).on_destroy().before(discard_if).template connect<&handler_type::discard_if>(*handler), ...); + (std::get &>(cpools).on_construct().before(discard_if).template connect<&handler_type::discard_if>(*handler), ...); - const auto *cpool = std::min({ - static_cast *>(std::get *>(cpools))..., - static_cast *>(std::get *>(cpools))... - }, [](const auto *lhs, const auto *rhs) { - return lhs->size() < rhs->size(); + const auto &cpool = std::min({ + static_cast &>(std::get &>(cpools))..., + static_cast &>(std::get &>(cpools))... + }, [](const auto &lhs, const auto &rhs) { + return lhs.size() < rhs.size(); }); // we cannot iterate backwards because we want to leave behind valid entities in case of owned types - std::for_each(cpool->data(), cpool->data() + cpool->size(), [cpools, handler](const auto entity) { - if((std::get *>(cpools)->has(entity) && ...) - && (std::get *>(cpools)->has(entity) && ...) - && !(std::get *>(cpools)->has(entity) || ...)) + std::for_each(cpool.data(), cpool.data() + cpool.size(), [cpools, handler](const auto entity) { + if((std::get &>(cpools).has(entity) && ...) + && (std::get &>(cpools).has(entity) && ...) + && !(std::get &>(cpools).has(entity) || ...)) { if constexpr(sizeof...(Owned) == 0) { handler->owned.construct(entity); } else { - if(!(std::get<0>(cpools)->index(entity) < handler->owned)) { + if(!(std::get<0>(cpools).index(entity) < handler->owned)) { const auto pos = handler->owned++; - (std::get *>(cpools)->swap(std::get *>(cpools)->data()[pos], entity), ...); + (std::get &>(cpools).swap(std::get &>(cpools).data()[pos], entity), ...); } } } @@ -1359,9 +1359,9 @@ public: } if constexpr(sizeof...(Owned) == 0) { - return { &handler->owned, std::get *>(cpools)... }; + return { handler->owned, std::get &>(cpools)... }; } else { - return { &std::get<0>(cpools)->super, &handler->owned, std::get *>(cpools)... , std::get *>(cpools)... }; + return { std::get<0>(cpools).super, handler->owned, std::get &>(cpools)... , std::get &>(cpools)... }; } } @@ -1493,7 +1493,7 @@ public: } } else { static_assert(sizeof...(Exclude) == 0 && std::conjunction_v...>); - (other.assure(*assure()), ...); + (other.assure(assure()), ...); } return other; diff --git a/src/entt/entity/view.hpp b/src/entt/entity/view.hpp index 0398206e4..a252b736e 100644 --- a/src/entt/entity/view.hpp +++ b/src/entt/entity/view.hpp @@ -154,10 +154,10 @@ class basic_view, Component...> { underlying_iterator_type it; }; - // we could use pool_type *..., but vs complains about it and refuses to compile for unknown reasons (likely a bug) - basic_view(storage> *... component, storage> *... epool) ENTT_NOEXCEPT - : pools{component...}, - filter{epool...} + // we could use pool_type &..., but vs complains about it and refuses to compile for unknown reasons (likely a bug) + basic_view(storage> &... component, storage> &... epool) ENTT_NOEXCEPT + : pools{&component...}, + filter{&epool...} {} const sparse_set * candidate() const ENTT_NOEXCEPT { @@ -565,8 +565,8 @@ class basic_view, Component> { using pool_type = std::conditional_t, const storage>, storage>; - basic_view(pool_type *ref) ENTT_NOEXCEPT - : pool{ref} + basic_view(pool_type &ref) ENTT_NOEXCEPT + : pool{&ref} {} public: