Fix modernize-type-traits lints (#3339)

zeroc-ice · Jan 13, 2025 · ce07f8f · ce07f8f
1 parent 1f95d5f
commit ce07f8f
Show file tree

Hide file tree

Showing 13 changed files with 49 additions and 56 deletions.
diff --git a/cpp/include/DataStorm/DataStorm.h b/cpp/include/DataStorm/DataStorm.h
@@ -1865,8 +1865,7 @@ namespace DataStorm
     };
 
     /** @private */
-    template<typename T, typename V>
-    struct RegexFilter<T, V, typename std::enable_if<DataStormI::is_streamable<V>::value>::type>
+    template<typename T, typename V> struct RegexFilter<T, V, std::enable_if_t<DataStormI::is_streamable<V>::value>>
     {
         template<typename F> static void add(F factory)
         {

diff --git a/cpp/include/DataStorm/InternalT.h b/cpp/include/DataStorm/InternalT.h
@@ -60,15 +60,15 @@ namespace DataStormI
         }
     };
 
-    template<typename T> struct EncoderT<T, typename std::enable_if<has_communicator_parameter<T>::value>::type>
+    template<typename T> struct EncoderT<T, std::enable_if_t<has_communicator_parameter<T>::value>>
     {
         static Ice::ByteSeq encode(const Ice::CommunicatorPtr& communicator, const T& value)
         {
             return DataStorm::Encoder<T>::encode(communicator, value);
         }
     };
 
-    template<typename T> struct DecoderT<T, typename std::enable_if<has_communicator_parameter<T>::value>::type>
+    template<typename T> struct DecoderT<T, std::enable_if_t<has_communicator_parameter<T>::value>>
     {
         static T decode(const Ice::CommunicatorPtr& communicator, const Ice::ByteSeq& data)
         {
@@ -97,7 +97,7 @@ namespace DataStormI
         }
     };
 
-    template<typename T> struct Stringifier<T, typename std::enable_if<is_streamable<T>::value>::type>
+    template<typename T> struct Stringifier<T, std::enable_if_t<is_streamable<T>::value>>
     {
         static std::string toString(const T& value)
         {
@@ -481,7 +481,7 @@ namespace DataStormI
 
     template<typename ValueT> class FilterManagerT final : public FilterManager
     {
-        using Value = typename std::remove_reference<decltype(std::declval<ValueT>().get())>::type;
+        using Value = std::remove_reference_t<decltype(std::declval<ValueT>().get())>;
 
         struct Factory
         {

diff --git a/cpp/include/Ice/Communicator.h b/cpp/include/Ice/Communicator.h
@@ -83,7 +83,7 @@ namespace Ice
          * @return The proxy, or nullopt if <code>str</code> is an empty string.
          * @see #proxyToString
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         std::optional<Prx> stringToProxy(std::string_view str) const
         {
             auto reference = _stringToProxy(str);
@@ -115,7 +115,7 @@ namespace Ice
          * @param property The base property name.
          * @return The proxy, or nullopt if the property is not set.
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         std::optional<Prx> propertyToProxy(std::string_view property) const
         {
             auto reference = _propertyToProxy(property);

diff --git a/cpp/include/Ice/Comparable.h b/cpp/include/Ice/Comparable.h
@@ -125,7 +125,7 @@ namespace Ice
         template<
             class C,
             std::enable_if_t<
-                std::is_member_function_pointer<decltype(&C::ice_tuple)>::value && !std::is_polymorphic_v<C>,
+                std::is_member_function_pointer_v<decltype(&C::ice_tuple)> && !std::is_polymorphic_v<C>,
                 bool> = true>
         bool operator<(const C& lhs, const C& rhs)
         {
@@ -141,7 +141,7 @@ namespace Ice
         template<
             class C,
             std::enable_if_t<
-                std::is_member_function_pointer<decltype(&C::ice_tuple)>::value && !std::is_polymorphic_v<C>,
+                std::is_member_function_pointer_v<decltype(&C::ice_tuple)> && !std::is_polymorphic_v<C>,
                 bool> = true>
         bool operator<=(const C& lhs, const C& rhs)
         {
@@ -157,7 +157,7 @@ namespace Ice
         template<
             class C,
             std::enable_if_t<
-                std::is_member_function_pointer<decltype(&C::ice_tuple)>::value && !std::is_polymorphic_v<C>,
+                std::is_member_function_pointer_v<decltype(&C::ice_tuple)> && !std::is_polymorphic_v<C>,
                 bool> = true>
         bool operator>(const C& lhs, const C& rhs)
         {
@@ -173,7 +173,7 @@ namespace Ice
         template<
             class C,
             std::enable_if_t<
-                std::is_member_function_pointer<decltype(&C::ice_tuple)>::value && !std::is_polymorphic_v<C>,
+                std::is_member_function_pointer_v<decltype(&C::ice_tuple)> && !std::is_polymorphic_v<C>,
                 bool> = true>
         bool operator>=(const C& lhs, const C& rhs)
         {
@@ -189,7 +189,7 @@ namespace Ice
         template<
             class C,
             std::enable_if_t<
-                std::is_member_function_pointer<decltype(&C::ice_tuple)>::value && !std::is_polymorphic_v<C>,
+                std::is_member_function_pointer_v<decltype(&C::ice_tuple)> && !std::is_polymorphic_v<C>,
                 bool> = true>
         bool operator==(const C& lhs, const C& rhs)
         {
@@ -205,7 +205,7 @@ namespace Ice
         template<
             class C,
             std::enable_if_t<
-                std::is_member_function_pointer<decltype(&C::ice_tuple)>::value && !std::is_polymorphic_v<C>,
+                std::is_member_function_pointer_v<decltype(&C::ice_tuple)> && !std::is_polymorphic_v<C>,
                 bool> = true>
         bool operator!=(const C& lhs, const C& rhs)
         {

diff --git a/cpp/include/Ice/Connection.h b/cpp/include/Ice/Connection.h
@@ -100,7 +100,7 @@ namespace Ice
          * @return A proxy that matches the given identity and uses this connection.
          * @see #setAdapter
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         [[nodiscard]] Prx createProxy(Identity id) const
         {
             return uncheckedCast<Prx>(_createProxy(std::move(id)));

diff --git a/cpp/include/Ice/InputStream.h b/cpp/include/Ice/InputStream.h
@@ -380,7 +380,7 @@ namespace Ice
          * @param tag The tag ID.
          * @param v Holds the extracted data (if any).
          */
-        template<typename T, std::enable_if_t<!std::is_base_of<ObjectPrx, T>::value, bool> = true>
+        template<typename T, std::enable_if_t<!std::is_base_of_v<ObjectPrx, T>, bool> = true>
         void read(std::int32_t tag, std::optional<T>& v)
         {
             if (readOptional(
@@ -404,7 +404,7 @@ namespace Ice
          * was set to nullopt (set to nullopt is supported for backward compatibility with Ice 3.7 and earlier
          * releases).
          */
-        template<typename T, std::enable_if_t<std::is_base_of<ObjectPrx, T>::value, bool> = true>
+        template<typename T, std::enable_if_t<std::is_base_of_v<ObjectPrx, T>, bool> = true>
         void read(std::int32_t tag, std::optional<T>& v)
         {
             if (readOptional(tag, OptionalFormat::FSize))
@@ -666,7 +666,7 @@ namespace Ice
          * Reads a typed proxy from the stream.
          * @param v The proxy as a user-defined type.
          */
-        template<typename Prx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         void read(std::optional<Prx>& v)
         {
             IceInternal::ReferencePtr ref = readReference();
@@ -684,8 +684,7 @@ namespace Ice
          * Reads a value (instance of a Slice class) from the stream (New mapping).
          * @param v The instance.
          */
-        template<typename T, typename std::enable_if<std::is_base_of<Value, T>::value>::type* = nullptr>
-        void read(std::shared_ptr<T>& v)
+        template<typename T, std::enable_if_t<std::is_base_of_v<Value, T>>* = nullptr> void read(std::shared_ptr<T>& v)
         {
             read(patchValue<T>, &v);
         }

diff --git a/cpp/include/Ice/LoggerUtil.h b/cpp/include/Ice/LoggerUtil.h
@@ -71,7 +71,7 @@ namespace Ice
         return LoggerOutputInserter<T, IsException<T>::value>::insert(out, val);
     }
 
-    template<typename Prx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+    template<typename Prx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
     inline LoggerOutputBase& operator<<(LoggerOutputBase& os, const std::optional<Prx>& p)
     {
         return os << (p ? p->ice_toString() : "");

diff --git a/cpp/include/Ice/MetricsObserverI.h b/cpp/include/Ice/MetricsObserverI.h
@@ -274,7 +274,7 @@ namespace IceMX
 
             static const std::string toString(const Ice::ObjectPrx& p) { return p->ice_toString(); }
 
-            template<typename Prx, std::enable_if_t<std::is_base_of<Ice::ObjectPrx, Prx>::value, bool> = true>
+            template<typename Prx, std::enable_if_t<std::is_base_of_v<Ice::ObjectPrx, Prx>, bool> = true>
             static const std::string toString(const std::optional<Prx>& p)
             {
                 return p ? toString(p.value()) : "";

diff --git a/cpp/include/Ice/ObjectAdapter.h b/cpp/include/Ice/ObjectAdapter.h
@@ -132,7 +132,7 @@ namespace Ice
          * @see #remove
          * @see #find
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         Prx add(const ObjectPtr& servant, const Identity& id)
         {
             return uncheckedCast<Prx>(_add(servant, id));
@@ -151,7 +151,7 @@ namespace Ice
          * @see #removeFacet
          * @see #findFacet
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         Prx addFacet(ObjectPtr servant, Identity id, std::string facet)
         {
             return uncheckedCast<Prx>(_addFacet(std::move(servant), std::move(id), std::move(facet)));
@@ -169,7 +169,7 @@ namespace Ice
          * @see #remove
          * @see #find
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         Prx addWithUUID(ObjectPtr servant)
         {
             return uncheckedCast<Prx>(_addWithUUID(std::move(servant)));
@@ -188,7 +188,7 @@ namespace Ice
          * @see #removeFacet
          * @see #findFacet
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         Prx addFacetWithUUID(ObjectPtr servant, std::string facet)
         {
             return uncheckedCast<Prx>(_addFacetWithUUID(std::move(servant), std::move(facet)));
@@ -379,7 +379,7 @@ namespace Ice
          * @return A proxy for the object with the given identity.
          * @see Identity
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         Prx createProxy(Identity id)
         {
             return uncheckedCast<Prx>(_createProxy(std::move(id)));
@@ -392,7 +392,7 @@ namespace Ice
          * @return A proxy for the object with the given identity.
          * @see Identity
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         Prx createDirectProxy(Identity id)
         {
             return uncheckedCast<Prx>(_createDirectProxy(std::move(id)));
@@ -406,7 +406,7 @@ namespace Ice
          * @return A proxy for the object with the given identity.
          * @see Identity
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         Prx createIndirectProxy(Identity id)
         {
             return uncheckedCast<Prx>(_createIndirectProxy(std::move(id)));

diff --git a/cpp/include/Ice/OutputStream.h b/cpp/include/Ice/OutputStream.h
@@ -340,7 +340,7 @@ namespace Ice
          * @param tag The tag ID.
          * @param v The data value to be written (if any).
          */
-        template<typename T, std::enable_if_t<!std::is_base_of<ObjectPrx, T>::value, bool> = true>
+        template<typename T, std::enable_if_t<!std::is_base_of_v<ObjectPrx, T>, bool> = true>
         void write(std::int32_t tag, const std::optional<T>& v)
         {
             if (!v)
@@ -362,7 +362,7 @@ namespace Ice
          * @param tag The tag ID.
          * @param v The proxy to be written (if any).
          */
-        template<typename T, std::enable_if_t<std::is_base_of<ObjectPrx, T>::value, bool> = true>
+        template<typename T, std::enable_if_t<std::is_base_of_v<ObjectPrx, T>, bool> = true>
         void write(std::int32_t tag, const std::optional<T>& v)
         {
             if (!v)
@@ -425,8 +425,7 @@ namespace Ice
         /**
          * Writes a list of mandatory data values.
          */
-        template<size_t I = 0, typename... Te>
-        typename std::enable_if<I == sizeof...(Te), void>::type writeAll(std::tuple<Te...>)
+        template<size_t I = 0, typename... Te> std::enable_if_t<I == sizeof...(Te), void> writeAll(std::tuple<Te...>)
         {
             // Do nothing. Either tuple is empty or we are at the end.
         }
@@ -435,7 +434,7 @@ namespace Ice
          * Writes a list of mandatory data values.
          */
         template<size_t I = 0, typename... Te>
-            typename std::enable_if < I<sizeof...(Te), void>::type writeAll(std::tuple<Te...> tuple)
+            std::enable_if_t < I<sizeof...(Te), void> writeAll(std::tuple<Te...> tuple)
         {
             write(std::get<I>(tuple));
             writeAll<I + 1, Te...>(tuple);
@@ -714,7 +713,7 @@ namespace Ice
          * Writes a proxy to the stream.
          * @param v The proxy to be write.
          */
-        template<typename Prx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         void write(const std::optional<Prx>& v)
         {
             if (v)
@@ -731,7 +730,7 @@ namespace Ice
          * Writes a value instance to the stream.
          * @param v The value to be written.
          */
-        template<typename T, typename std::enable_if<std::is_base_of<Value, T>::value>::type* = nullptr>
+        template<typename T, std::enable_if_t<std::is_base_of_v<Value, T>>* = nullptr>
         void write(const std::shared_ptr<T>& v)
         {
             initEncaps();

diff --git a/cpp/include/Ice/Proxy.h b/cpp/include/Ice/Proxy.h
@@ -631,7 +631,7 @@ namespace Ice
          * @param id The identity for the new proxy.
          * @return A proxy with the new identity.
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         [[nodiscard]] Prx ice_identity(Ice::Identity id) const
         {
             return Prx::_fromReference(_identity(std::move(id)));
@@ -654,7 +654,7 @@ namespace Ice
          * @param facet The facet for the new proxy.
          * @return A proxy with the new facet.
          */
-        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of<ObjectPrx, Prx>::value, bool> = true>
+        template<typename Prx = ObjectPrx, std::enable_if_t<std::is_base_of_v<ObjectPrx, Prx>, bool> = true>
         [[nodiscard]] Prx ice_facet(std::string facet) const
         {
             return Prx::_fromReference(_facet(std::move(facet)));