sigh mixin: operator bool and registry functions

src/entt/entity/mixin.hpp

@@ -259,6 +259,27 @@ class basic_sigh_mixin final: public Type {
  return sink{destruction};
  }
 
+ /**
+ * @brief Checks if a mixin refers to a valid registry.
+ * @return True if the mixin refers to a valid registry, false otherwise.
+ */
+ [[nodiscard]] explicit operator bool() const noexcept {
+ return (owner != nullptr);
+ }
+
+ /**
+ * @brief Returns a pointer to the underlying registry, if any.
+ * @return A pointer to the underlying registry, if any.
+ */
+ [[nodiscard]] const registry_type &registry() const noexcept {
+ return owner_or_assert();
+ }
+
+ /*! @copydoc registry */
+ [[nodiscard]] registry_type &registry() noexcept {
+ return owner_or_assert();
+ }
+
  /**
  * @brief Emplace elements into a storage.
  *

test/entt/entity/sigh_mixin.cpp

@@ -10,6 +10,7 @@
 #include <entt/entity/mixin.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/entity/storage.hpp>
+#include "../../common/config.h"
 #include "../../common/entity.h"
 #include "../../common/linter.hpp"
 #include "../../common/non_default_constructible.h"
@@ -57,9 +58,13 @@ struct SighMixin: testing::Test {
  using type = Type;
 };
 
+template<typename Type>
+using SighMixinDeathTest = SighMixin<Type>;
+
 using SighMixinTypes = ::testing::Types<int, test::pointer_stable>;
 
 TYPED_TEST_SUITE(SighMixin, SighMixinTypes, );
+TYPED_TEST_SUITE(SighMixinDeathTest, SighMixinTypes, );
 
 TYPED_TEST(SighMixin, Functionalities) {
  using value_type = typename TestFixture::type;
@@ -459,23 +464,50 @@ TEST(SighMixin, AutoSignal) {
  ASSERT_FALSE(registry.valid(entity));
 }
 
+TYPED_TEST(SighMixin, Registry) {
+ using value_type = typename TestFixture::type;
+
+ entt::registry registry;
+ entt::sigh_mixin<entt::storage<value_type>> pool;
+
+ ASSERT_FALSE(pool);
+
+ pool.bind(registry);
+
+ ASSERT_TRUE(pool);
+ ASSERT_EQ(&pool.registry(), &registry);
+ ASSERT_EQ(&std::as_const(pool).registry(), &registry);
+}
+
+ENTT_DEBUG_TYPED_TEST(SighMixinDeathTest, Registry) {
+ using value_type = typename TestFixture::type;
+ entt::sigh_mixin<entt::storage<value_type>> pool;
+ ASSERT_DEATH([[maybe_unused]] auto &registry = pool.registry(), "");
+ ASSERT_DEATH([[maybe_unused]] const auto &registry = std::as_const(pool).registry(), "");
+}
+
 TYPED_TEST(SighMixin, CustomRegistry) {
  using value_type = typename TestFixture::type;
  using registry_type = test::basic_custom_registry<test::entity>;
 
  registry_type registry;
- auto &pool = registry.storage<value_type>();
+ entt::basic_sigh_mixin<entt::basic_storage<value_type, test::entity>, registry_type> pool;
+ const std::array entity{registry.create(), registry.create()};
+
+ ASSERT_FALSE(pool);
 
- testing::StaticAssertTypeEq<decltype(pool), entt::basic_sigh_mixin<entt::basic_storage<value_type, test::entity>, registry_type> &>();
+ pool.bind(static_cast<entt::basic_registry<test::entity> &>(registry));
+
+ ASSERT_TRUE(pool);
 
  std::size_t on_construct{};
  std::size_t on_destroy{};
 
  pool.on_construct().template connect<&listener<registry_type>>(on_construct);
  pool.on_destroy().template connect<&listener<registry_type>>(on_destroy);
 
- pool.emplace(registry.create());
- pool.emplace(registry.create());
+ pool.emplace(entity[0u]);
+ pool.emplace(entity[1u]);
 
  ASSERT_EQ(on_construct, 2u);
  ASSERT_EQ(on_destroy, 0u);
@@ -486,6 +518,14 @@ TYPED_TEST(SighMixin, CustomRegistry) {
  ASSERT_EQ(on_destroy, 2u);
 }
 
+ENTT_DEBUG_TYPED_TEST(SighMixinDeathTest, CustomRegistry) {
+ using value_type = typename TestFixture::type;
+ using registry_type = test::basic_custom_registry<test::entity>;
+ entt::basic_sigh_mixin<entt::basic_storage<value_type, test::entity>, registry_type> pool;
+ ASSERT_DEATH([[maybe_unused]] auto &registry = pool.registry(), "");
+ ASSERT_DEATH([[maybe_unused]] const auto &registry = std::as_const(pool).registry(), "");
+}
+
 TYPED_TEST(SighMixin, CustomAllocator) {
  using value_type = typename TestFixture::type;
  using storage_type = entt::sigh_mixin<entt::basic_storage<value_type, entt::entity, test::throwing_allocator<value_type>>>;