handle: decouple from entity type, make it work with all registry types

src/entt/entity/fwd.hpp

@@ -111,24 +111,24 @@ using observer = basic_observer<registry>;
 using organizer = basic_organizer<entity>;
 
 /*! @brief Alias declaration for the most common use case. */
-using handle = basic_handle<entity>;
+using handle = basic_handle<registry>;
 
 /*! @brief Alias declaration for the most common use case. */
-using const_handle = basic_handle<const entity>;
+using const_handle = basic_handle<const registry>;
 
 /**
  * @brief Alias declaration for the most common use case.
  * @tparam Args Other template parameters.
  */
 template<typename... Args>
-using handle_view = basic_handle<entity, Args...>;
+using handle_view = basic_handle<registry, Args...>;
 
 /**
  * @brief Alias declaration for the most common use case.
  * @tparam Args Other template parameters.
  */
 template<typename... Args>
-using const_handle_view = basic_handle<const entity, Args...>;
+using const_handle_view = basic_handle<const registry, Args...>;
 
 /*! @brief Alias declaration for the most common use case. */
 using snapshot = basic_snapshot<registry>;

src/entt/entity/handle.hpp

@@ -15,13 +15,13 @@ namespace entt {
  *
  * Tiny wrapper around a registry and an entity.
  *
- * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Type Basic registry type.
  * @tparam Scope Types to which to restrict the scope of a handle.
  */
-template<typename Entity, typename... Scope>
+template<typename Type, typename... Scope>
 struct basic_handle {
     /*! @brief Type of registry accepted by the handle. */
-    using registry_type = constness_as_t<basic_registry<std::remove_const_t<Entity>>, Entity>;
+    using registry_type = Type;
     /*! @brief Underlying entity identifier. */
     using entity_type = typename registry_type::entity_type;
     /*! @brief Underlying version type. */
@@ -52,7 +52,7 @@ struct basic_handle {
      */
     template<typename Other, typename... Args>
     operator basic_handle<Other, Args...>() const noexcept {
-        static_assert(std::is_same_v<Other, Entity> || std::is_same_v<std::remove_const_t<Other>, Entity>, "Invalid conversion between different handles");
+        static_assert(std::is_same_v<Other, Type> || std::is_same_v<std::remove_const_t<Other>, Type>, "Invalid conversion between different handles");
         static_assert((sizeof...(Scope) == 0 || ((sizeof...(Args) != 0 && sizeof...(Args) <= sizeof...(Scope)) && ... && (type_list_contains_v<type_list<Scope...>, Args>))), "Invalid conversion between different handles");
 
         return reg ? basic_handle<Other, Args...>{*reg, entt} : basic_handle<Other, Args...>{};
@@ -320,20 +320,6 @@ template<typename... Args, typename... Other>
     return !(lhs == rhs);
 }
 
-/**
- * @brief Deduction guide.
- * @tparam Entity A valid entity type (see entt_traits for more details).
- */
-template<typename Entity>
-basic_handle(basic_registry<Entity> &, Entity) -> basic_handle<Entity>;
-
-/**
- * @brief Deduction guide.
- * @tparam Entity A valid entity type (see entt_traits for more details).
- */
-template<typename Entity>
-basic_handle(const basic_registry<Entity> &, Entity) -> basic_handle<const Entity>;
-
 } // namespace entt
 
 #endif

test/entt/entity/handle.cpp

@@ -17,8 +17,8 @@ TEST(BasicHandle, Assumptions) {
 }
 
 TEST(BasicHandle, DeductionGuide) {
-    static_assert(std::is_same_v<decltype(entt::basic_handle{std::declval<entt::registry &>(), {}}), entt::basic_handle<entt::entity>>);
-    static_assert(std::is_same_v<decltype(entt::basic_handle{std::declval<const entt::registry &>(), {}}), entt::basic_handle<const entt::entity>>);
+    static_assert(std::is_same_v<decltype(entt::basic_handle{std::declval<entt::registry &>(), {}}), entt::basic_handle<entt::registry>>);
+    static_assert(std::is_same_v<decltype(entt::basic_handle{std::declval<const entt::registry &>(), {}}), entt::basic_handle<const entt::registry>>);
 }
 
 TEST(BasicHandle, Construction) {