entt::resource_cache -> entt::cache

docs/md/resource.md

@@ -76,11 +76,11 @@ Finally, a cache is a specialization of a class template tailored to a specific
 resource:
 
 ```cpp
-using my_resource_cache = entt::resource_cache<my_resource>;
+using my_cache = entt::cache<my_resource>;
 
 // ...
 
-my_resource_cache cache{};
+my_cache cache{};
 ```
 
 The idea is to create different caches for different types of resources and to
@@ -109,7 +109,7 @@ Before to explore this part of the interface, it makes sense to mention how
 resources are identified. The type of the identifiers to use is defined as:
 
 ```cpp
-entt::resource_cache<resource>::resource_type
+entt::cache<resource>::resource_type
 ```
 
 Where `resource_type` is an alias for `entt::hashed_string::hash_type`.
@@ -117,7 +117,7 @@ Therefore, resource identifiers are created explicitly as in the following
 example:
 
 ```cpp
-constexpr auto identifier = entt::resource_cache<resource>::resource_type{"my/resource/identifier"_hs};
+constexpr auto identifier = entt::cache<resource>::resource_type{"my/resource/identifier"_hs};
 // this is equivalent to the following
 constexpr auto hs = entt::hashed_string{"my/resource/identifier"};
 ```

src/entt/resource/cache.hpp

@@ -26,20 +26,20 @@ namespace entt {
  * @tparam Resource Type of resources managed by a cache.
  */
 template<typename Resource>
-struct resource_cache {
+struct cache {
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Type of resources managed by a cache. */
     using resource_type = ENTT_ID_TYPE;
 
     /*! @brief Default constructor. */
-    resource_cache() = default;
+    cache() = default;
 
     /*! @brief Default move constructor. */
-    resource_cache(resource_cache &&) = default;
+    cache(cache &&) = default;
 
     /*! @brief Default move assignment operator. @return This cache. */
-    resource_cache & operator=(resource_cache &&) = default;
+    cache & operator=(cache &&) = default;
 
     /**
      * @brief Number of resources managed by a cache.

src/entt/resource/fwd.hpp

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

src/entt/resource/handle.hpp

@@ -26,7 +26,7 @@ namespace entt {
 template<typename Resource>
 class handle {
     /*! @brief Resource handles are friends of their caches. */
-    friend struct resource_cache<Resource>;
+    friend struct cache<Resource>;
 
     handle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
         : resource{std::move(res)}

src/entt/resource/loader.hpp

@@ -44,7 +44,7 @@ namespace entt {
 template<typename Loader, typename Resource>
 class loader {
     /*! @brief Resource loaders are friends of their caches. */
-    friend struct resource_cache<Resource>;
+    friend struct cache<Resource>;
 
     /**
      * @brief Loads the resource and returns it.

test/entt/resource/resource.cpp

@@ -18,12 +18,12 @@ struct broken_loader: entt::loader<broken_loader, resource> {
 };
 
 TEST(Resource, Functionalities) {
-    entt::resource_cache<resource> cache;
+    entt::cache<resource> cache;
 
     constexpr auto hs1 = entt::hashed_string{"res1"};
     constexpr auto hs2 = entt::hashed_string{"res2"};
 
-    ASSERT_EQ(cache.size(), entt::resource_cache<resource>::size_type{});
+    ASSERT_EQ(cache.size(), entt::cache<resource>::size_type{});
     ASSERT_TRUE(cache.empty());
     ASSERT_FALSE(cache.contains(hs1));
     ASSERT_FALSE(cache.contains(hs2));
@@ -31,7 +31,7 @@ TEST(Resource, Functionalities) {
     ASSERT_FALSE(cache.load<broken_loader>(hs1, 42));
     ASSERT_FALSE(cache.reload<broken_loader>(hs1, 42));
 
-    ASSERT_EQ(cache.size(), entt::resource_cache<resource>::size_type{});
+    ASSERT_EQ(cache.size(), entt::cache<resource>::size_type{});
     ASSERT_TRUE(cache.empty());
     ASSERT_FALSE(cache.contains(hs1));
     ASSERT_FALSE(cache.contains(hs2));
@@ -39,7 +39,7 @@ TEST(Resource, Functionalities) {
     ASSERT_TRUE(cache.load<loader>(hs1, 42));
     ASSERT_TRUE(cache.reload<loader>(hs1, 42));
 
-    ASSERT_NE(cache.size(), entt::resource_cache<resource>::size_type{});
+    ASSERT_NE(cache.size(), entt::cache<resource>::size_type{});
     ASSERT_FALSE(cache.empty());
     ASSERT_TRUE(cache.contains(hs1));
     ASSERT_FALSE(cache.contains(hs2));
@@ -48,7 +48,7 @@ TEST(Resource, Functionalities) {
     ASSERT_TRUE(cache.load<loader>(hs1, 42));
     ASSERT_TRUE(cache.load<loader>(hs2, 42));
 
-    ASSERT_NE(cache.size(), entt::resource_cache<resource>::size_type{});
+    ASSERT_NE(cache.size(), entt::cache<resource>::size_type{});
     ASSERT_FALSE(cache.empty());
     ASSERT_TRUE(cache.contains(hs1));
     ASSERT_TRUE(cache.contains(hs2));
@@ -64,14 +64,14 @@ TEST(Resource, Functionalities) {
     ASSERT_TRUE(cache.load<loader>(hs1, 42));
     ASSERT_NO_THROW(cache.clear());
 
-    ASSERT_EQ(cache.size(), entt::resource_cache<resource>::size_type{});
+    ASSERT_EQ(cache.size(), entt::cache<resource>::size_type{});
     ASSERT_TRUE(cache.empty());
     ASSERT_FALSE(cache.contains(hs1));
     ASSERT_FALSE(cache.contains(hs2));
 
     ASSERT_TRUE(cache.load<loader>(hs1, 42));
 
-    ASSERT_NE(cache.size(), entt::resource_cache<resource>::size_type{});
+    ASSERT_NE(cache.size(), entt::cache<resource>::size_type{});
     ASSERT_FALSE(cache.empty());
     ASSERT_TRUE(cache.handle(hs1));
     ASSERT_FALSE(cache.handle(hs2));
@@ -80,7 +80,7 @@ TEST(Resource, Functionalities) {
     ASSERT_EQ(&cache.handle(hs1).get(), &static_cast<const resource &>(cache.handle(hs1)));
     ASSERT_NO_THROW(cache.clear());
 
-    ASSERT_EQ(cache.size(), entt::resource_cache<resource>::size_type{});
+    ASSERT_EQ(cache.size(), entt::cache<resource>::size_type{});
     ASSERT_TRUE(cache.empty());
 
     ASSERT_TRUE(cache.temp<loader>(42));
@@ -94,7 +94,7 @@ TEST(Resource, Functionalities) {
 }
 
 TEST(Resource, MutableHandle) {
-    entt::resource_cache<resource> cache;
+    entt::cache<resource> cache;
 
     constexpr auto hs = entt::hashed_string{"res"};
     auto handle = cache.load<loader>(hs, 0);
@@ -110,7 +110,7 @@ TEST(Resource, MutableHandle) {
 }
 
 TEST(Resource, Each) {
-    entt::resource_cache<resource> cache;
+    entt::cache<resource> cache;
     cache.load<loader>("resource"_hs, 0);
 
     cache.each([](entt::handle<resource> res) {
@@ -128,7 +128,7 @@ TEST(Resource, Each) {
     ASSERT_FALSE(cache.empty());
     ASSERT_EQ(cache.handle("resource"_hs)->value, 2);
 
-    cache.each([&cache](entt::resource_cache<resource>::resource_type id) {
+    cache.each([&cache](entt::cache<resource>::resource_type id) {
         cache.discard(id);
     });