resource: remove use_count (close #889)

src/entt/resource/resource.hpp

@@ -149,19 +149,11 @@ public:
         return static_cast<bool>(value);
     }
 
-    /**
-     * @brief Returns the number of handles pointing the same resource.
-     * @return The number of handles pointing the same resource.
-     */
-    [[nodiscard]] long use_count() const noexcept {
-        return value.use_count();
-    }
-
     /**
      * @brief Returns the underlying resource handle.
      * @return The underlying resource handle.
      */
-    [[nodiscard]] handle_type handle() const noexcept {
+    [[nodiscard]] const handle_type &handle() const noexcept {
         return value;
     }
 

test/entt/resource/resource.cpp

@@ -39,7 +39,7 @@ TEST(Resource, Functionalities) {
     ASSERT_EQ(other.operator->(), value.get());
     ASSERT_EQ(&static_cast<derived &>(other), value.get());
     ASSERT_EQ(&*other, value.get());
-    ASSERT_EQ(other.use_count(), 2l);
+    ASSERT_EQ(other.handle().use_count(), 2l);
 
     entt::resource<derived> copy{resource};
     entt::resource<derived> move{std::move(other)};
@@ -90,12 +90,12 @@ TEST(Resource, ConstNonConstAndAllInBetween) {
     ASSERT_TRUE(copy);
     ASSERT_EQ(copy, resource);
     ASSERT_NE(copy, entt::resource<derived>{});
-    ASSERT_EQ(copy.use_count(), 3u);
+    ASSERT_EQ(copy.handle().use_count(), 3u);
 
     ASSERT_TRUE(move);
     ASSERT_EQ(move, resource);
     ASSERT_NE(move, entt::resource<derived>{});
-    ASSERT_EQ(move.use_count(), 3u);
+    ASSERT_EQ(move.handle().use_count(), 3u);
 
     copy = resource;
     move = std::move(resource);
@@ -105,7 +105,7 @@ TEST(Resource, ConstNonConstAndAllInBetween) {
 
     ASSERT_TRUE(copy);
     ASSERT_TRUE(move);
-    ASSERT_EQ(copy.use_count(), 2u);
+    ASSERT_EQ(copy.handle().use_count(), 2u);
 }
 
 TEST(Resource, DynamicResourceHandleCast) {
@@ -113,20 +113,20 @@ TEST(Resource, DynamicResourceHandleCast) {
     entt::resource<const base> other = resource;
 
     ASSERT_TRUE(other);
-    ASSERT_EQ(resource.use_count(), 2u);
+    ASSERT_EQ(resource.handle().use_count(), 2u);
     ASSERT_EQ(resource, other);
 
     entt::resource<const derived> cast = dynamic_resource_cast<const derived>(other);
 
     ASSERT_TRUE(cast);
-    ASSERT_EQ(resource.use_count(), 3u);
+    ASSERT_EQ(resource.handle().use_count(), 3u);
     ASSERT_EQ(resource, cast);
 
     other = entt::resource<base>{std::make_shared<base>()};
     cast = dynamic_resource_cast<const derived>(other);
 
     ASSERT_FALSE(cast);
-    ASSERT_EQ(resource.use_count(), 1u);
+    ASSERT_EQ(resource.handle().use_count(), 1u);
 }
 
 TEST(Resource, Comparison) {