entt::resource_handle -> entt::handle

src/entt/resource/cache.hpp

@@ -90,20 +90,20 @@ struct resource_cache {
      * @return A handle for the given resource.
      */
     template<typename Loader, typename... Args>
-    resource_handle<Resource> load(const resource_type id, Args &&... args) {
+    entt::handle<Resource> load(const resource_type id, Args &&... args) {
         static_assert(std::is_base_of_v<loader<Loader, Resource>, Loader>);
-        resource_handle<Resource> handle{};
+        entt::handle<Resource> resource{};
 
         if(auto it = resources.find(id); it == resources.cend()) {
-            if(auto resource = Loader{}.get(std::forward<Args>(args)...); resource) {
-                resources[id] = resource;
-                handle = std::move(resource);
+            if(auto instance = Loader{}.get(std::forward<Args>(args)...); instance) {
+                resources[id] = instance;
+                resource = std::move(instance);
             }
         } else {
-            handle = it->second;
+            resource = it->second;
         }
 
-        return handle;
+        return resource;
     }
 
     /**
@@ -130,7 +130,7 @@ struct resource_cache {
      * @return A handle for the given resource.
      */
     template<typename Loader, typename... Args>
-    resource_handle<Resource> reload(const resource_type id, Args &&... args) {
+    entt::handle<Resource> reload(const resource_type id, Args &&... args) {
         return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
     }
 
@@ -147,7 +147,7 @@ struct resource_cache {
      * @return A handle for the given resource.
      */
     template<typename Loader, typename... Args>
-    resource_handle<Resource> temp(Args &&... args) const {
+    entt::handle<Resource> temp(Args &&... args) const {
         return { Loader{}.get(std::forward<Args>(args)...) };
     }
 
@@ -159,12 +159,12 @@ struct resource_cache {
      * cache contains the resource itself. Otherwise the returned handle is
      * uninitialized and accessing it results in undefined behavior.
      *
-     * @sa resource_handle
+     * @sa handle
      *
      * @param id Unique resource identifier.
      * @return A handle for the given resource.
      */
-    resource_handle<Resource> handle(const resource_type id) const {
+    entt::handle<Resource> handle(const resource_type id) const {
         auto it = resources.find(id);
         return { it == resources.end() ? nullptr : it->second };
     }
@@ -202,8 +202,8 @@ struct resource_cache {
      *
      * @code{.cpp}
      * void(const resource_type);
-     * void(resource_handle<Resource>);
-     * void(const resource_type, resource_handle<Resource>);
+     * void(handle<Resource>);
+     * void(const resource_type, handle<Resource>);
      * @endcode
      *
      * @tparam Func Type of the function object to invoke.
@@ -219,10 +219,10 @@ struct resource_cache {
 
             if constexpr(std::is_invocable_v<Func, resource_type>) {
                 func(curr->first);
-            } else if constexpr(std::is_invocable_v<Func, resource_handle<Resource>>) {
-                func(resource_handle{ curr->second });
+            } else if constexpr(std::is_invocable_v<Func, entt::handle<Resource>>) {
+                func(entt::handle{ curr->second });
             } else {
-                func(curr->first, resource_handle{ curr->second });
+                func(curr->first, entt::handle{ curr->second });
             }
         }
     }

src/entt/resource/fwd.hpp

@@ -12,9 +12,9 @@ namespace entt {
 template<typename>
 struct resource_cache;
 
-/*! @class resource_handle */
+/*! @class handle */
 template<typename>
-class resource_handle;
+class handle;
 
 /*! @class loader */
 template<typename, typename>

src/entt/resource/handle.hpp

@@ -24,17 +24,17 @@ namespace entt {
  * @tparam Resource Type of resource managed by a handle.
  */
 template<typename Resource>
-class resource_handle {
+class handle {
     /*! @brief Resource handles are friends of their caches. */
     friend struct resource_cache<Resource>;
 
-    resource_handle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
+    handle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
         : resource{std::move(res)}
     {}
 
 public:
     /*! @brief Default constructor. */
-    resource_handle() ENTT_NOEXCEPT = default;
+    handle() ENTT_NOEXCEPT = default;
 
     /**
      * @brief Gets a reference to the managed resource.

test/entt/resource/resource.cpp

@@ -86,11 +86,11 @@ TEST(Resource, Functionalities) {
     ASSERT_TRUE(cache.temp<loader>(42));
     ASSERT_TRUE(cache.empty());
 
-    ASSERT_FALSE(entt::resource_handle<resource>{});
-    ASSERT_TRUE(std::is_copy_constructible_v<entt::resource_handle<resource>>);
-    ASSERT_TRUE(std::is_move_constructible_v<entt::resource_handle<resource>>);
-    ASSERT_TRUE(std::is_copy_assignable_v<entt::resource_handle<resource>>);
-    ASSERT_TRUE(std::is_move_assignable_v<entt::resource_handle<resource>>);
+    ASSERT_FALSE(entt::handle<resource>{});
+    ASSERT_TRUE(std::is_copy_constructible_v<entt::handle<resource>>);
+    ASSERT_TRUE(std::is_move_constructible_v<entt::handle<resource>>);
+    ASSERT_TRUE(std::is_copy_assignable_v<entt::handle<resource>>);
+    ASSERT_TRUE(std::is_move_assignable_v<entt::handle<resource>>);
 }
 
 TEST(Resource, MutableHandle) {
@@ -113,7 +113,7 @@ TEST(Resource, Each) {
     entt::resource_cache<resource> cache;
     cache.load<loader>("resource"_hs, 0);
 
-    cache.each([](entt::resource_handle<resource> res) {
+    cache.each([](entt::handle<resource> res) {
         ++res->value;
     });