stl: std::decay_t

src/entt/container/dense_set.hpp

@@ -544,7 +544,7 @@ public:
      */
     template<typename... Args>
     stl::pair<iterator, bool> emplace(Args &&...args) {
-        if constexpr(((sizeof...(Args) == 1u) && ... && stl::is_same_v<std::decay_t<Args>, value_type>)) {
+        if constexpr(((sizeof...(Args) == 1u) && ... && stl::is_same_v<stl::decay_t<Args>, value_type>)) {
             return insert_or_do_nothing(stl::forward<Args>(args)...);
         } else {
             auto &node = packed.first().emplace_back(std::piecewise_construct, stl::make_tuple(packed.first().size()), stl::forward_as_tuple(stl::forward<Args>(args)...));

src/entt/core/any.hpp

@@ -226,7 +226,7 @@ public:
     template<typename Type>
     requires (!std::same_as<stl::remove_cvref_t<Type>, basic_any>)
     basic_any(Type &&value)
-        : basic_any{std::in_place_type<std::decay_t<Type>>, stl::forward<Type>(value)} {}
+        : basic_any{std::in_place_type<stl::decay_t<Type>>, stl::forward<Type>(value)} {}
 
     /**
      * @brief Copy constructor.
@@ -311,7 +311,7 @@ public:
     template<typename Type>
     requires (!std::same_as<stl::remove_cvref_t<Type>, basic_any>)
     basic_any &operator=(Type &&value) {
-        emplace<std::decay_t<Type>>(stl::forward<Type>(value));
+        emplace<stl::decay_t<Type>>(stl::forward<Type>(value));
         return *this;
     }
 

src/entt/core/compressed_pair.hpp

@@ -232,7 +232,7 @@ public:
  * @tparam Other Type of value to use to initialize the second element.
  */
 template<typename Type, typename Other>
-compressed_pair(Type &&, Other &&) -> compressed_pair<std::decay_t<Type>, std::decay_t<Other>>;
+compressed_pair(Type &&, Other &&) -> compressed_pair<stl::decay_t<Type>, stl::decay_t<Other>>;
 
 /**
  * @brief Swaps two compressed pair objects.

src/entt/core/ident.hpp

@@ -17,7 +17,7 @@ template<typename... Type>
 class ident {
     template<typename Curr, std::size_t... Index>
     [[nodiscard]] static ENTT_CONSTEVAL id_type get(std::index_sequence<Index...>) noexcept {
-        return (0 + ... + (stl::is_same_v<Curr, type_list_element_t<Index, type_list<std::decay_t<Type>...>>> ? id_type{Index} : id_type{}));
+        return (0 + ... + (stl::is_same_v<Curr, type_list_element_t<Index, type_list<stl::decay_t<Type>...>>> ? id_type{Index} : id_type{}));
     }
 
 public:

src/entt/entity/helper.hpp

@@ -104,7 +104,7 @@ private:
  * @param reg A registry that contains the given entity and its elements.
  * @param entt Entity from which to get the element.
  */
-template<auto Member, typename Registry = std::decay_t<nth_argument_t<0u, decltype(Member)>>>
+template<auto Member, typename Registry = stl::decay_t<nth_argument_t<0u, decltype(Member)>>>
 void invoke(Registry &reg, const typename Registry::entity_type entt) {
     static_assert(std::is_member_function_pointer_v<decltype(Member)>, "Invalid pointer to non-static member function");
     (reg.template get<member_class_t<decltype(Member)>>(entt).*Member)(reg, entt);

src/entt/entity/snapshot.hpp

@@ -320,8 +320,8 @@ class basic_continuous_loader {
         Container other;
 
         for(auto &&pair: container) {
-            using first_type = stl::remove_const_t<typename std::decay_t<decltype(pair)>::first_type>;
-            using second_type = std::decay_t<decltype(pair)>::second_type;
+            using first_type = stl::remove_const_t<typename stl::decay_t<decltype(pair)>::first_type>;
+            using second_type = stl::decay_t<decltype(pair)>::second_type;
 
             if constexpr(stl::is_same_v<first_type, entity_type> && stl::is_same_v<second_type, entity_type>) {
                 other.emplace(map(pair.first), map(pair.second));

src/entt/meta/meta.hpp

@@ -305,7 +305,7 @@ public:
     template<typename Type>
     requires (!std::same_as<stl::remove_cvref_t<Type>, meta_any>)
     meta_any(const meta_ctx &area, Type &&value)
-        : meta_any{area, std::in_place_type<std::decay_t<Type>>, stl::forward<Type>(value)} {}
+        : meta_any{area, std::in_place_type<stl::decay_t<Type>>, stl::forward<Type>(value)} {}
 
     /**
      * @brief Context aware copy constructor.
@@ -391,7 +391,7 @@ public:
     template<typename Type>
     requires (!std::same_as<stl::remove_cvref_t<Type>, meta_any>)
     meta_any &operator=(Type &&value) {
-        emplace<std::decay_t<Type>>(stl::forward<Type>(value));
+        emplace<stl::decay_t<Type>>(stl::forward<Type>(value));
         return *this;
     }
 
@@ -1058,7 +1058,7 @@ class meta_type {
         bool ambiguous{};
 
         for(auto curr = next(); curr; curr = next()) {
-            if constexpr(stl::is_same_v<std::decay_t<decltype(*curr)>, internal::meta_func_node>) {
+            if constexpr(stl::is_same_v<stl::decay_t<decltype(*curr)>, internal::meta_func_node>) {
                 if(constness && !(curr->traits & internal::meta_traits::is_const)) {
                     continue;
                 }
@@ -1087,7 +1087,7 @@ class meta_type {
                         same = match;
                         ambiguous = false;
                     } else if(match == same) {
-                        if constexpr(stl::is_same_v<std::decay_t<decltype(*curr)>, internal::meta_func_node>) {
+                        if constexpr(stl::is_same_v<stl::decay_t<decltype(*curr)>, internal::meta_func_node>) {
                             if(!!(curr->traits & internal::meta_traits::is_const) != !!(candidate->traits & internal::meta_traits::is_const)) {
                                 candidate = !!(candidate->traits & internal::meta_traits::is_const) ? curr : candidate;
                                 ambiguous = false;

src/entt/meta/node.hpp

@@ -247,15 +247,15 @@ auto setup_node_for() noexcept {
     if constexpr(!stl::is_void_v<Type> && !std::is_function_v<Type>) {
         node.from_void = +[](const meta_ctx &ctx, void *elem, const void *celem) {
             if(elem && celem) { // ownership construction request
-                return meta_any{ctx, std::in_place, static_cast<std::decay_t<Type> *>(elem)};
+                return meta_any{ctx, std::in_place, static_cast<stl::decay_t<Type> *>(elem)};
             }
 
             if(elem) { // non-const reference construction request
-                return meta_any{ctx, std::in_place_type<std::decay_t<Type> &>, *static_cast<std::decay_t<Type> *>(elem)};
+                return meta_any{ctx, std::in_place_type<stl::decay_t<Type> &>, *static_cast<stl::decay_t<Type> *>(elem)};
             }
 
             // const reference construction request
-            return meta_any{ctx, std::in_place_type<const std::decay_t<Type> &>, *static_cast<const std::decay_t<Type> *>(celem)};
+            return meta_any{ctx, std::in_place_type<const stl::decay_t<Type> &>, *static_cast<const stl::decay_t<Type> *>(celem)};
         };
     }
 

src/entt/signal/dispatcher.hpp

@@ -218,7 +218,7 @@ public:
      */
     template<typename Type>
     [[nodiscard]] size_type size(const id_type id = type_hash<Type>::value()) const noexcept {
-        const auto *cpool = assure<std::decay_t<Type>>(id);
+        const auto *cpool = assure<stl::decay_t<Type>>(id);
         return cpool ? cpool->size() : 0u;
     }
 
@@ -267,7 +267,7 @@ public:
      */
     template<typename Type>
     void trigger(Type value) {
-        trigger(type_hash<std::decay_t<Type>>::value(), value);
+        trigger(type_hash<stl::decay_t<Type>>::value(), value);
     }
 
     /**
@@ -278,7 +278,7 @@ public:
      */
     template<typename Type>
     void trigger(const id_type id, Type value) {
-        assure<std::decay_t<Type>>(id).trigger(value);
+        assure<stl::decay_t<Type>>(id).trigger(value);
     }
 
     /**
@@ -299,7 +299,7 @@ public:
      */
     template<typename Type>
     void enqueue(Type &&value) {
-        enqueue_hint(type_hash<std::decay_t<Type>>::value(), stl::forward<Type>(value));
+        enqueue_hint(type_hash<stl::decay_t<Type>>::value(), stl::forward<Type>(value));
     }
 
     /**
@@ -322,7 +322,7 @@ public:
      */
     template<typename Type>
     void enqueue_hint(const id_type id, Type &&value) {
-        assure<std::decay_t<Type>>(id).enqueue(stl::forward<Type>(value));
+        assure<stl::decay_t<Type>>(id).enqueue(stl::forward<Type>(value));
     }
 
     /**

src/entt/stl/type_traits.hpp

@@ -6,6 +6,7 @@
 /*! @cond ENTT_INTERNAL */
 namespace entt::stl {
 
+using std::decay_t;
 using std::false_type;
 using std::invoke_result_t;
 using std::is_invocable_r_v;

src/entt/tools/davey.hpp

@@ -149,7 +149,7 @@ static void present_storage(const meta_ctx &ctx, const basic_sparse_set<Entity,
 
             if(ImGui::TreeNode(&storage.info(), "%d [%d/%d]", to_integral(entt), to_entity(entt), to_version(entt))) {
                 if(const auto obj = type.from_void(storage.value(entt)); obj) {
-                    present_element<typename std::decay_t<decltype(storage)>::entity_type>(obj, [](const char *name, const Entity entt) {
+                    present_element<typename stl::decay_t<decltype(storage)>::entity_type>(obj, [](const char *name, const Entity entt) {
                         ImGui::Text("%s: %d [%d/%d]", name, to_integral(entt), to_entity(entt), to_version(entt));
                     });
                 }