group: add ::handle function to all group types

src/entt/entity/group.hpp

@@ -236,8 +236,8 @@ public:
           filter{&epool...} {}
 
     /**
-     * @brief Returns a const reference to the underlying handler.
-     * @return A const reference to the underlying handler.
+     * @brief Returns the leading storage of a group.
+     * @return The leading storage of the group.
      */
     [[nodiscard]] const base_type &handle() const noexcept {
         return *descriptor;
@@ -643,6 +643,14 @@ public:
           pools{&opool..., &gpool...},
           filter{&epool...} {}
 
+    /**
+     * @brief Returns the leading storage of a group.
+     * @return The leading storage of the group.
+     */
+    [[nodiscard]] const base_type &handle() const noexcept {
+        return *std::get<0>(pools);
+    }
+
     /**
      * @brief Returns the storage for a given component type.
      * @tparam Type Type of component of which to return the storage.

test/entt/entity/group.cpp

@@ -93,6 +93,7 @@ TEST(NonOwningGroup, Handle) {
     ASSERT_TRUE(handle.empty());
     ASSERT_FALSE(handle.contains(entity));
     ASSERT_EQ(&handle, &group.handle());
+    ASSERT_NE(&handle, &group.storage<int>());
 
     registry.emplace<int>(entity);
     registry.emplace<char>(entity);
@@ -762,6 +763,7 @@ TEST(OwningGroup, Functionalities) {
         ASSERT_EQ(cgroup.get<const char>(entity), '2');
     }
 
+    ASSERT_EQ(group.handle().data()[0u], e1);
     ASSERT_EQ(group.storage<int>().raw()[0u][0u], 42);
 
     registry.erase<char>(e0);
@@ -780,6 +782,26 @@ TEST(OwningGroup, Functionalities) {
     ASSERT_FALSE(invalid);
 }
 
+TEST(OwningGroup, Handle) {
+    entt::registry registry;
+    const auto entity = registry.create();
+
+    auto group = registry.group<int>(entt::get<char>);
+    auto &&handle = group.handle();
+
+    ASSERT_TRUE(handle.empty());
+    ASSERT_FALSE(handle.contains(entity));
+    ASSERT_EQ(&handle, &group.handle());
+    ASSERT_EQ(&handle, &group.storage<int>());
+
+    registry.emplace<int>(entity);
+    registry.emplace<char>(entity);
+
+    ASSERT_FALSE(handle.empty());
+    ASSERT_TRUE(handle.contains(entity));
+    ASSERT_EQ(&handle, &group.handle());
+}
+
 TEST(OwningGroup, Invalid) {
     entt::registry registry{};
     auto group = std::as_const(registry).group_if_exists<const int>(entt::get<const empty_type>);
@@ -930,11 +952,11 @@ TEST(OwningGroup, SortOrdered) {
         return group.get<boxed_int>(lhs).value < group.get<boxed_int>(rhs).value;
     });
 
-    ASSERT_EQ(group.storage<boxed_int>().data()[0u], entities[0]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[1u], entities[1]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[2u], entities[2]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[3u], entities[3]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[4u], entities[4]);
+    ASSERT_EQ(group.handle().data()[0u], entities[0]);
+    ASSERT_EQ(group.handle().data()[1u], entities[1]);
+    ASSERT_EQ(group.handle().data()[2u], entities[2]);
+    ASSERT_EQ(group.handle().data()[3u], entities[3]);
+    ASSERT_EQ(group.handle().data()[4u], entities[4]);
 
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][0u].value, 12);
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][1u].value, 9);
@@ -977,11 +999,11 @@ TEST(OwningGroup, SortReverse) {
         return lhs.value < rhs.value;
     });
 
-    ASSERT_EQ(group.storage<boxed_int>().data()[0u], entities[2]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[1u], entities[1]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[2u], entities[0]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[3u], entities[3]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[4u], entities[4]);
+    ASSERT_EQ(group.handle().data()[0u], entities[2]);
+    ASSERT_EQ(group.handle().data()[1u], entities[1]);
+    ASSERT_EQ(group.handle().data()[2u], entities[0]);
+    ASSERT_EQ(group.handle().data()[3u], entities[3]);
+    ASSERT_EQ(group.handle().data()[4u], entities[4]);
 
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][0u].value, 12);
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][1u].value, 9);
@@ -1032,13 +1054,13 @@ TEST(OwningGroup, SortUnordered) {
         return std::get<1>(lhs) < std::get<1>(rhs);
     });
 
-    ASSERT_EQ(group.storage<boxed_int>().data()[0u], entities[4]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[1u], entities[3]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[2u], entities[0]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[3u], entities[1]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[4u], entities[2]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[5u], entities[5]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[6u], entities[6]);
+    ASSERT_EQ(group.handle().data()[0u], entities[4]);
+    ASSERT_EQ(group.handle().data()[1u], entities[3]);
+    ASSERT_EQ(group.handle().data()[2u], entities[0]);
+    ASSERT_EQ(group.handle().data()[3u], entities[1]);
+    ASSERT_EQ(group.handle().data()[4u], entities[2]);
+    ASSERT_EQ(group.handle().data()[5u], entities[5]);
+    ASSERT_EQ(group.handle().data()[6u], entities[6]);
 
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][0u].value, 12);
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][1u].value, 9);
@@ -1048,11 +1070,11 @@ TEST(OwningGroup, SortUnordered) {
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][5u].value, 4);
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][6u].value, 5);
 
-    ASSERT_EQ(group.get<char>(group.storage<boxed_int>().data()[0u]), 'e');
-    ASSERT_EQ(group.get<char>(group.storage<boxed_int>().data()[1u]), 'd');
-    ASSERT_EQ(group.get<char>(group.storage<boxed_int>().data()[2u]), 'c');
-    ASSERT_EQ(group.get<char>(group.storage<boxed_int>().data()[3u]), 'b');
-    ASSERT_EQ(group.get<char>(group.storage<boxed_int>().data()[4u]), 'a');
+    ASSERT_EQ(group.get<char>(group.handle().data()[0u]), 'e');
+    ASSERT_EQ(group.get<char>(group.handle().data()[1u]), 'd');
+    ASSERT_EQ(group.get<char>(group.handle().data()[2u]), 'c');
+    ASSERT_EQ(group.get<char>(group.handle().data()[3u]), 'b');
+    ASSERT_EQ(group.get<char>(group.handle().data()[4u]), 'a');
 
     ASSERT_FALSE(group.contains(entities[5]));
     ASSERT_FALSE(group.contains(entities[6]));
@@ -1077,10 +1099,10 @@ TEST(OwningGroup, SortWithExclusionList) {
         return lhs < rhs;
     });
 
-    ASSERT_EQ(group.storage<boxed_int>().data()[0u], entities[4]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[1u], entities[3]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[2u], entities[1]);
-    ASSERT_EQ(group.storage<boxed_int>().data()[3u], entities[0]);
+    ASSERT_EQ(group.handle().data()[0u], entities[4]);
+    ASSERT_EQ(group.handle().data()[1u], entities[3]);
+    ASSERT_EQ(group.handle().data()[2u], entities[1]);
+    ASSERT_EQ(group.handle().data()[3u], entities[0]);
 
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][0u].value, 4);
     ASSERT_EQ(group.storage<boxed_int>().raw()[0u][1u].value, 3);