const T & = --> std::as_const

test/entt/entity/actor.cpp

@@ -6,10 +6,9 @@
 TEST(Actor, Component) {
     entt::registry<> registry;
     entt::actor actor{registry};
-    const auto &cactor = actor;
 
     ASSERT_EQ(&registry, &actor.backend());
-    ASSERT_EQ(&registry, &cactor.backend());
+    ASSERT_EQ(&registry, &std::as_const(actor).backend());
     ASSERT_TRUE(registry.empty<int>());
     ASSERT_FALSE(registry.empty());
     ASSERT_FALSE(actor.has<int>());
@@ -18,7 +17,7 @@ TEST(Actor, Component) {
     const auto &cchar = actor.assign<char>();
 
     ASSERT_EQ(&cint, &actor.get<int>());
-    ASSERT_EQ(&cchar, &cactor.get<char>());
+    ASSERT_EQ(&cchar, &std::as_const(actor).get<char>());
     ASSERT_EQ(&cint, &std::get<0>(actor.get<int, char>()));
     ASSERT_EQ(&cchar, &std::get<1>(actor.get<int, char>()));
     ASSERT_EQ(&cint, std::get<0>(actor.try_get<int, char, double>()));

test/entt/entity/group.cpp

@@ -666,9 +666,8 @@ TEST(OwningGroup, EmptyAndNonEmptyTypes) {
 
 TEST(NonOwningGroup, TrackEntitiesOnComponentDestruction) {
     entt::registry<> registry;
-    const entt::registry<> &cregistry = registry;
     const auto group = registry.group<>(entt::get<int>, entt::exclude<char>);
-    const auto cgroup = cregistry.group<>(entt::get<const int>, entt::exclude<char>);
+    const auto cgroup = std::as_const(registry).group<>(entt::get<const int>, entt::exclude<char>);
 
     const auto entity = registry.create();
     registry.assign<int>(entity);
@@ -685,9 +684,8 @@ TEST(NonOwningGroup, TrackEntitiesOnComponentDestruction) {
 
 TEST(OwningGroup, TrackEntitiesOnComponentDestruction) {
     entt::registry<> registry;
-    const entt::registry<> &cregistry = registry;
     const auto group = registry.group<int>(entt::exclude<char>);
-    const auto cgroup = cregistry.group<const int>(entt::exclude<char>);
+    const auto cgroup = std::as_const(registry).group<const int>(entt::exclude<char>);
 
     const auto entity = registry.create();
     registry.assign<int>(entity);

test/entt/entity/prototype.cpp

@@ -5,10 +5,9 @@
 TEST(Prototype, SameRegistry) {
     entt::registry<> registry;
     entt::prototype prototype{registry};
-    const auto &cprototype = prototype;
 
     ASSERT_EQ(&registry, &prototype.backend());
-    ASSERT_EQ(&registry, &cprototype.backend());
+    ASSERT_EQ(&registry, &std::as_const(prototype).backend());
     ASSERT_FALSE(registry.empty());
     ASSERT_FALSE((prototype.has<int, char>()));
 
@@ -17,17 +16,17 @@ TEST(Prototype, SameRegistry) {
     ASSERT_EQ(prototype.set<char>('c'), 'c');
 
     ASSERT_EQ(prototype.get<int>(), 3);
-    ASSERT_EQ(cprototype.get<char>(), 'c');
+    ASSERT_EQ(std::as_const(prototype).get<char>(), 'c');
     ASSERT_EQ(std::get<0>(prototype.get<int, char>()), 3);
-    ASSERT_EQ(std::get<1>(cprototype.get<int, char>()), 'c');
+    ASSERT_EQ(std::get<1>(std::as_const(prototype).get<int, char>()), 'c');
 
     ASSERT_NE(prototype.try_get<int>(), nullptr);
     ASSERT_NE(prototype.try_get<char>(), nullptr);
     ASSERT_EQ(prototype.try_get<double>(), nullptr);
     ASSERT_EQ(*prototype.try_get<int>(), 3);
-    ASSERT_EQ(*cprototype.try_get<char>(), 'c');
+    ASSERT_EQ(*std::as_const(prototype).try_get<char>(), 'c');
     ASSERT_EQ(*std::get<0>(prototype.try_get<int, char, double>()), 3);
-    ASSERT_EQ(*std::get<1>(cprototype.try_get<int, char, double>()), 'c');
+    ASSERT_EQ(*std::get<1>(std::as_const(prototype).try_get<int, char, double>()), 'c');
 
     const auto e0 = prototype.create();
 
@@ -75,7 +74,6 @@ TEST(Prototype, OtherRegistry) {
     entt::registry<> registry;
     entt::registry<> repository;
     entt::prototype prototype{repository};
-    const auto &cprototype = prototype;
 
     ASSERT_TRUE(registry.empty());
     ASSERT_FALSE((prototype.has<int, char>()));
@@ -85,9 +83,9 @@ TEST(Prototype, OtherRegistry) {
     ASSERT_EQ(prototype.set<char>('c'), 'c');
 
     ASSERT_EQ(prototype.get<int>(), 3);
-    ASSERT_EQ(cprototype.get<char>(), 'c');
+    ASSERT_EQ(std::as_const(prototype).get<char>(), 'c');
     ASSERT_EQ(std::get<0>(prototype.get<int, char>()), 3);
-    ASSERT_EQ(std::get<1>(cprototype.get<int, char>()), 'c');
+    ASSERT_EQ(std::get<1>(std::as_const(prototype).get<int, char>()), 'c');
 
     const auto e0 = prototype.create(registry);
 

test/entt/entity/registry.cpp

@@ -217,22 +217,21 @@ TEST(Registry, Identifiers) {
 
 TEST(Registry, RawData) {
     entt::registry<> registry;
-    const entt::registry<> &cregistry = registry;
     const auto entity = registry.create();
 
     ASSERT_EQ(registry.raw<int>(), nullptr);
-    ASSERT_EQ(cregistry.raw<int>(), nullptr);
-    ASSERT_EQ(cregistry.data<int>(), nullptr);
+    ASSERT_EQ(std::as_const(registry).raw<int>(), nullptr);
+    ASSERT_EQ(std::as_const(registry).data<int>(), nullptr);
 
     registry.assign<int>(entity, 42);
 
     ASSERT_NE(registry.raw<int>(), nullptr);
-    ASSERT_NE(cregistry.raw<int>(), nullptr);
-    ASSERT_NE(cregistry.data<int>(), nullptr);
+    ASSERT_NE(std::as_const(registry).raw<int>(), nullptr);
+    ASSERT_NE(std::as_const(registry).data<int>(), nullptr);
 
     ASSERT_EQ(*registry.raw<int>(), 42);
-    ASSERT_EQ(*cregistry.raw<int>(), 42);
-    ASSERT_EQ(*cregistry.data<int>(), entity);
+    ASSERT_EQ(*std::as_const(registry).raw<int>(), 42);
+    ASSERT_EQ(*std::as_const(registry).data<int>(), entity);
 }
 
 TEST(Registry, CreateDestroyCornerCase) {

test/entt/entity/sparse_set.cpp

@@ -7,14 +7,13 @@
 
 TEST(SparseSetNoType, Functionalities) {
     entt::sparse_set<std::uint64_t> set;
-    const auto &cset = set;
 
     set.reserve(42);
 
     ASSERT_EQ(set.capacity(), 42);
     ASSERT_TRUE(set.empty());
     ASSERT_EQ(set.size(), 0u);
-    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(std::as_const(set).begin(), std::as_const(set).end());
     ASSERT_EQ(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_FALSE(set.has(42));
@@ -25,7 +24,7 @@ TEST(SparseSetNoType, Functionalities) {
 
     ASSERT_FALSE(set.empty());
     ASSERT_EQ(set.size(), 1u);
-    ASSERT_NE(cset.begin(), cset.end());
+    ASSERT_NE(std::as_const(set).begin(), std::as_const(set).end());
     ASSERT_NE(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_TRUE(set.has(42));
@@ -36,7 +35,7 @@ TEST(SparseSetNoType, Functionalities) {
 
     ASSERT_TRUE(set.empty());
     ASSERT_EQ(set.size(), 0u);
-    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(std::as_const(set).begin(), std::as_const(set).end());
     ASSERT_EQ(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_FALSE(set.has(42));
@@ -49,7 +48,7 @@ TEST(SparseSetNoType, Functionalities) {
 
     ASSERT_TRUE(set.empty());
     ASSERT_EQ(set.size(), 0u);
-    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(std::as_const(set).begin(), std::as_const(set).end());
     ASSERT_EQ(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_FALSE(set.has(42));
@@ -143,7 +142,6 @@ TEST(SparseSetNoType, Data) {
 TEST(SparseSetNoType, RespectDisjoint) {
     entt::sparse_set<std::uint64_t> lhs;
     entt::sparse_set<std::uint64_t> rhs;
-    const auto &clhs = lhs;
 
     lhs.construct(3);
     lhs.construct(12);
@@ -155,15 +153,14 @@ TEST(SparseSetNoType, RespectDisjoint) {
 
     lhs.respect(rhs);
 
-    ASSERT_EQ(clhs.get(3), 0u);
-    ASSERT_EQ(clhs.get(12), 1u);
-    ASSERT_EQ(clhs.get(42), 2u);
+    ASSERT_EQ(std::as_const(lhs).get(3), 0u);
+    ASSERT_EQ(std::as_const(lhs).get(12), 1u);
+    ASSERT_EQ(std::as_const(lhs).get(42), 2u);
 }
 
 TEST(SparseSetNoType, RespectOverlap) {
     entt::sparse_set<std::uint64_t> lhs;
     entt::sparse_set<std::uint64_t> rhs;
-    const auto &clhs = lhs;
 
     lhs.construct(3);
     lhs.construct(12);
@@ -177,9 +174,9 @@ TEST(SparseSetNoType, RespectOverlap) {
 
     lhs.respect(rhs);
 
-    ASSERT_EQ(clhs.get(3), 0u);
-    ASSERT_EQ(clhs.get(12), 2u);
-    ASSERT_EQ(clhs.get(42), 1u);
+    ASSERT_EQ(std::as_const(lhs).get(3), 0u);
+    ASSERT_EQ(std::as_const(lhs).get(12), 2u);
+    ASSERT_EQ(std::as_const(lhs).get(42), 1u);
 }
 
 TEST(SparseSetNoType, RespectOrdered) {
@@ -347,14 +344,13 @@ TEST(SparseSetNoType, Clone) {
 
 TEST(SparseSetWithType, Functionalities) {
     entt::sparse_set<std::uint64_t, int> set;
-    const auto &cset = set;
 
     set.reserve(42);
 
     ASSERT_EQ(set.capacity(), 42);
     ASSERT_TRUE(set.empty());
     ASSERT_EQ(set.size(), 0u);
-    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(std::as_const(set).begin(), std::as_const(set).end());
     ASSERT_EQ(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_FALSE(set.has(42));
@@ -363,7 +359,7 @@ TEST(SparseSetWithType, Functionalities) {
 
     ASSERT_FALSE(set.empty());
     ASSERT_EQ(set.size(), 1u);
-    ASSERT_NE(cset.begin(), cset.end());
+    ASSERT_NE(std::as_const(set).begin(), std::as_const(set).end());
     ASSERT_NE(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_TRUE(set.has(42));
@@ -376,7 +372,7 @@ TEST(SparseSetWithType, Functionalities) {
 
     ASSERT_TRUE(set.empty());
     ASSERT_EQ(set.size(), 0u);
-    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(std::as_const(set).begin(), std::as_const(set).end());
     ASSERT_EQ(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_FALSE(set.has(42));
@@ -391,7 +387,7 @@ TEST(SparseSetWithType, Functionalities) {
 
     ASSERT_TRUE(set.empty());
     ASSERT_EQ(set.size(), 0u);
-    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(std::as_const(set).begin(), std::as_const(set).end());
     ASSERT_EQ(set.begin(), set.end());
     ASSERT_FALSE(set.has(0));
     ASSERT_FALSE(set.has(42));
@@ -404,12 +400,11 @@ TEST(SparseSetWithType, Functionalities) {
 TEST(SparseSetWithType, FunctionalitiesEmptyType) {
     struct empty_type {};
     entt::sparse_set<std::uint64_t, empty_type> set;
-    const auto &cset = set;
 
     ASSERT_EQ(&set.construct(42), &set.construct(99));
     ASSERT_EQ(&set.get(42), set.try_get(42));
     ASSERT_EQ(&set.get(42), &set.get(99));
-    ASSERT_EQ(cset.try_get(42), cset.try_get(99));
+    ASSERT_EQ(std::as_const(set).try_get(42), std::as_const(set).try_get(99));
 }
 
 TEST(SparseSetWithType, AggregatesMustWork) {
@@ -611,29 +606,27 @@ TEST(SparseSetWithType, ConstIteratorEmptyType) {
 
 TEST(SparseSetWithType, Raw) {
     entt::sparse_set<std::uint64_t, int> set;
-    const auto &cset = set;
 
     set.construct(3, 3);
     set.construct(12, 6);
     set.construct(42, 9);
 
     ASSERT_EQ(set.get(3), 3);
-    ASSERT_EQ(cset.get(12), 6);
+    ASSERT_EQ(std::as_const(set).get(12), 6);
     ASSERT_EQ(set.get(42), 9);
 
     ASSERT_EQ(*(set.raw() + 0u), 3);
-    ASSERT_EQ(*(cset.raw() + 1u), 6);
+    ASSERT_EQ(*(std::as_const(set).raw() + 1u), 6);
     ASSERT_EQ(*(set.raw() + 2u), 9);
 }
 
 TEST(SparseSetWithType, RawEmptyType) {
     struct empty_type {};
     entt::sparse_set<std::uint64_t, empty_type> set;
-    const auto &cset = set;
 
     set.construct(3);
 
-    ASSERT_EQ(set.raw(), cset.raw());
+    ASSERT_EQ(set.raw(), std::as_const(set).raw());
     ASSERT_EQ(set.try_get(3), set.raw());
 }
 
@@ -748,21 +741,20 @@ TEST(SparseSetWithType, SortUnordered) {
 TEST(SparseSetWithType, RespectDisjoint) {
     entt::sparse_set<std::uint64_t, int> lhs;
     entt::sparse_set<std::uint64_t, int> rhs;
-    const auto &clhs = lhs;
 
     lhs.construct(3, 3);
     lhs.construct(12, 6);
     lhs.construct(42, 9);
 
-    ASSERT_EQ(clhs.get(3), 3);
-    ASSERT_EQ(clhs.get(12), 6);
-    ASSERT_EQ(clhs.get(42), 9);
+    ASSERT_EQ(std::as_const(lhs).get(3), 3);
+    ASSERT_EQ(std::as_const(lhs).get(12), 6);
+    ASSERT_EQ(std::as_const(lhs).get(42), 9);
 
     lhs.respect(rhs);
 
-    ASSERT_EQ(*(clhs.raw() + 0u), 3);
-    ASSERT_EQ(*(clhs.raw() + 1u), 6);
-    ASSERT_EQ(*(clhs.raw() + 2u), 9);
+    ASSERT_EQ(*(std::as_const(lhs).raw() + 0u), 3);
+    ASSERT_EQ(*(std::as_const(lhs).raw() + 1u), 6);
+    ASSERT_EQ(*(std::as_const(lhs).raw() + 2u), 9);
 
     auto begin = lhs.begin();
     auto end = lhs.end();
@@ -776,23 +768,22 @@ TEST(SparseSetWithType, RespectDisjoint) {
 TEST(SparseSetWithType, RespectOverlap) {
     entt::sparse_set<std::uint64_t, int> lhs;
     entt::sparse_set<std::uint64_t, int> rhs;
-    const auto &clhs = lhs;
 
     lhs.construct(3, 3);
     lhs.construct(12, 6);
     lhs.construct(42, 9);
     rhs.construct(12, 6);
 
-    ASSERT_EQ(clhs.get(3), 3);
-    ASSERT_EQ(clhs.get(12), 6);
-    ASSERT_EQ(clhs.get(42), 9);
+    ASSERT_EQ(std::as_const(lhs).get(3), 3);
+    ASSERT_EQ(std::as_const(lhs).get(12), 6);
+    ASSERT_EQ(std::as_const(lhs).get(42), 9);
     ASSERT_EQ(rhs.get(12), 6);
 
     lhs.respect(rhs);
 
-    ASSERT_EQ(*(clhs.raw() + 0u), 3);
-    ASSERT_EQ(*(clhs.raw() + 1u), 9);
-    ASSERT_EQ(*(clhs.raw() + 2u), 6);
+    ASSERT_EQ(*(std::as_const(lhs).raw() + 0u), 3);
+    ASSERT_EQ(*(std::as_const(lhs).raw() + 1u), 9);
+    ASSERT_EQ(*(std::as_const(lhs).raw() + 2u), 6);
 
     auto begin = lhs.begin();
     auto end = lhs.end();
@@ -945,7 +936,6 @@ TEST(SparseSetWithType, RespectOverlapEmptyType) {
     struct empty_type {};
     entt::sparse_set<std::uint64_t, empty_type> lhs;
     entt::sparse_set<std::uint64_t, empty_type> rhs;
-    const auto &clhs = lhs;
 
     lhs.construct(3);
     lhs.construct(12);
@@ -959,9 +949,9 @@ TEST(SparseSetWithType, RespectOverlapEmptyType) {
 
     lhs.respect(rhs);
 
-    ASSERT_EQ(clhs.sparse_set<std::uint64_t>::get(3), 0u);
-    ASSERT_EQ(clhs.sparse_set<std::uint64_t>::get(12), 2u);
-    ASSERT_EQ(clhs.sparse_set<std::uint64_t>::get(42), 1u);
+    ASSERT_EQ(std::as_const(lhs).sparse_set<std::uint64_t>::get(3), 0u);
+    ASSERT_EQ(std::as_const(lhs).sparse_set<std::uint64_t>::get(12), 2u);
+    ASSERT_EQ(std::as_const(lhs).sparse_set<std::uint64_t>::get(42), 1u);
 }
 
 TEST(SparseSetWithType, CanModifyDuringIteration) {
@@ -1059,7 +1049,7 @@ TEST(SparseSetWithType, CloneMoveOnlyComponent) {
 TEST(SparseSetWithType, ConstructorExceptionDoesNotAddToSet) {
     struct throwing_component {
         struct constructor_exception: std::exception {};
-        
+
         throwing_component() { throw constructor_exception{}; }
 
         // necessary to avoid the short-circuit construct() logic for empty objects

test/entt/entity/view.cpp

@@ -111,7 +111,6 @@ TEST(SingleComponentView, Each) {
     registry.assign<int>(registry.create());
 
     auto view = registry.view<int>();
-    const auto &cview = static_cast<const decltype(view) &>(view);
     std::size_t cnt = 0;
 
     view.each([&cnt](auto, int &) { ++cnt; });
@@ -119,8 +118,8 @@ TEST(SingleComponentView, Each) {
 
     ASSERT_EQ(cnt, std::size_t{4});
 
-    cview.each([&cnt](auto, const int &) { --cnt; });
-    cview.each([&cnt](const int &) { --cnt; });
+    std::as_const(view).each([&cnt](auto, const int &) { --cnt; });
+    std::as_const(view).each([&cnt](const int &) { --cnt; });
 
     ASSERT_EQ(cnt, std::size_t{0});
 }
@@ -128,7 +127,7 @@ TEST(SingleComponentView, Each) {
 TEST(SingleComponentView, ConstNonConstAndAllInBetween) {
     entt::registry<> registry;
     auto view = registry.view<int>();
-    auto cview = registry.view<const int>();
+    auto cview = std::as_const(registry).view<const int>();
 
     ASSERT_EQ(view.size(), decltype(view.size()){0});
     ASSERT_EQ(cview.size(), decltype(cview.size()){0});