Use C++14 way of using type traits

joto · joto · commit 21966e02f192 · 2024-12-17T14:33:22.000+01:00
diff --git a/include/osmium/builder/attr.hpp b/include/osmium/builder/attr.hpp
@@ -182,7 +182,7 @@ namespace osmium {
 
 #define OSMIUM_ATTRIBUTE_WITH_CONSTRUCTOR(_handler, _name, _type) \
     OSMIUM_ATTRIBUTE(_handler, _name, _type) \
-        constexpr explicit _name(std::add_const<_type>::type& value) : \
+        constexpr explicit _name(std::add_const_t<_type>& value) : \
             type_wrapper(value) {} \
     }
 
@@ -658,7 +658,7 @@ namespace osmium {
             }
 
             template <typename TFirst, typename... TRest>
-            constexpr typename std::enable_if<!std::is_same<attr::_user, TFirst>::value, const char*>::type
+            constexpr std::enable_if_t<!std::is_same<attr::_user, TFirst>::value, const char*>
             get_user(const TFirst& /*first*/, const TRest&... args) noexcept {
                 return get_user(args...);
             }
@@ -802,12 +802,12 @@ namespace osmium {
             // ==============================================================
 
             template <typename TBuilder, typename THandler, typename... TArgs>
-            inline typename std::enable_if<!is_handled_by<THandler, TArgs...>::value>::type
+            inline std::enable_if_t<!is_handled_by<THandler, TArgs...>::value>
             add_list(osmium::builder::Builder& /*parent*/, const TArgs&... /*args*/) noexcept {
             }
 
             template <typename TBuilder, typename THandler, typename... TArgs>
-            inline typename std::enable_if<is_handled_by<THandler, TArgs...>::value>::type
+            inline std::enable_if_t<is_handled_by<THandler, TArgs...>::value>
             add_list(osmium::builder::Builder& parent, const TArgs&... args) {
                 TBuilder builder{parent.buffer(), &parent};
                 (void)std::initializer_list<int>{
diff --git a/include/osmium/index/relations_map.hpp b/include/osmium/index/relations_map.hpp
@@ -95,7 +95,7 @@ namespace osmium {
                     m_map.emplace_back(key, value);
                 }
 
-                typename std::enable_if<std::is_same<TKey, TValue>::value>::type flip_in_place() {
+                std::enable_if_t<std::is_same<TKey, TValue>::value> flip_in_place() {
                     for (auto& p : m_map) {
                         using std::swap;
                         swap(p.key, p.value);
diff --git a/include/osmium/memory/collection.hpp b/include/osmium/memory/collection.hpp
@@ -49,7 +49,7 @@ namespace osmium {
             // This data_type is either 'unsigned char*' or 'const unsigned
             // char*' depending on whether TMember is const. This allows this
             // class to be used as an iterator and as a const_iterator.
-            using data_type = typename std::conditional<std::is_const<TMember>::value, const unsigned char*, unsigned char*>::type;
+            using data_type = std::conditional_t<std::is_const<TMember>::value, const unsigned char*, unsigned char*>;
 
             data_type m_data;
 
diff --git a/include/osmium/memory/item_iterator.hpp b/include/osmium/memory/item_iterator.hpp
@@ -63,7 +63,7 @@ namespace osmium {
             // This data_type is either 'unsigned char*' or 'const unsigned char*' depending
             // on whether TMember is const. This allows this class to be used as an iterator and
             // as a const_iterator.
-            using data_type = typename std::conditional<std::is_const<TMember>::value, const unsigned char*, unsigned char*>::type;
+            using data_type = std::conditional_t<std::is_const<TMember>::value, const unsigned char*, unsigned char*>;
 
             data_type m_data;
             data_type m_end;
@@ -179,7 +179,7 @@ namespace osmium {
 
             // This data_type is either 'unsigned char*' or
             // 'const unsigned char*' depending on whether T is const.
-            using data_type = typename std::conditional<std::is_const<T>::value, const unsigned char*, unsigned char*>::type;
+            using data_type = std::conditional_t<std::is_const<T>::value, const unsigned char*, unsigned char*>;
 
             data_type m_begin;
             data_type m_end;
diff --git a/include/osmium/osm/entity_bits.hpp b/include/osmium/osm/entity_bits.hpp
@@ -115,7 +115,7 @@ namespace osmium {
          *      changeset.
          */
         inline type from_item_type(osmium::item_type item_type) noexcept {
-            const auto ut = static_cast<std::underlying_type<osmium::item_type>::type>(item_type);
+            const auto ut = static_cast<std::underlying_type_t<osmium::item_type>>(item_type);
             assert(ut <= 0x05);
             if (ut == 0) {
                 return nothing;
diff --git a/include/osmium/osm/timestamp.hpp b/include/osmium/osm/timestamp.hpp
@@ -220,7 +220,7 @@ namespace osmium {
          * The constructor is not declared "explicit" so that conversions
          * like @code node.set_timestamp(123); @endcode work.
          */
-        template <typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
+        template <typename T, typename std::enable_if_t<std::is_integral<T>::value, int> = 0>
         constexpr Timestamp(T timestamp) noexcept : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_timestamp(static_cast<uint32_t>(timestamp)) {
         }
diff --git a/include/osmium/relations/relations_manager.hpp b/include/osmium/relations/relations_manager.hpp
@@ -304,7 +304,7 @@ namespace osmium {
         template <typename TManager, bool TNodes, bool TWays, bool TRelations, bool TCheckOrder = true>
         class RelationsManager : public RelationsManagerBase {
 
-            using check_order_handler = typename std::conditional<TCheckOrder, osmium::handler::CheckOrder, osmium::handler::Handler>::type;
+            using check_order_handler = std::conditional_t<TCheckOrder, osmium::handler::CheckOrder, osmium::handler::Handler>;
 
             check_order_handler m_check_order_handler;
 
diff --git a/include/osmium/tags/filter.hpp b/include/osmium/tags/filter.hpp
@@ -92,7 +92,7 @@ namespace osmium {
         class Filter {
 
             using key_type   = TKey;
-            using value_type = typename std::conditional<std::is_void<TValue>::value, bool, TValue>::type;
+            using value_type = std::conditional_t<std::is_void<TValue>::value, bool, TValue>;
 
             struct Rule {
                 key_type key;
@@ -130,7 +130,7 @@ namespace osmium {
                 m_default_result(default_result) {
             }
 
-            template <typename V = TValue, typename std::enable_if<!std::is_void<V>::value, int>::type = 0>
+            template <typename V = TValue, typename std::enable_if_t<!std::is_void<V>::value, int> = 0>
             Filter& add(bool result, const key_type& key, const value_type& value) {
                 m_rules.emplace_back(result, false, key, value);
                 return *this;
diff --git a/include/osmium/tags/matcher.hpp b/include/osmium/tags/matcher.hpp
@@ -72,8 +72,8 @@ namespace osmium {
          *
          * @param key_matcher StringMatcher for matching the key.
          */
-        template <typename TKey, typename X = typename std::enable_if<
-            std::is_convertible<TKey, osmium::StringMatcher>::value, void>::type>
+        template <typename TKey, typename X = std::enable_if_t<
+            std::is_convertible<TKey, osmium::StringMatcher>::value, void>>
         explicit TagMatcher(TKey&& key_matcher) :
             m_key_matcher(std::forward<TKey>(key_matcher)),
             m_value_matcher(osmium::StringMatcher::always_true{}) {
@@ -88,8 +88,8 @@ namespace osmium {
          * @param invert If set to true, invert the result of the value_matcher.
          */
         template <typename TKey, typename TValue,
-            typename std::enable_if<std::is_convertible<TKey, osmium::StringMatcher>::value, int>::type = 0,
-            typename std::enable_if<std::is_convertible<TValue, osmium::StringMatcher>::value, int>::type = 0>
+            typename std::enable_if_t<std::is_convertible<TKey, osmium::StringMatcher>::value, int> = 0,
+            typename std::enable_if_t<std::is_convertible<TValue, osmium::StringMatcher>::value, int> = 0>
         TagMatcher(TKey&& key_matcher, TValue&& value_matcher, bool invert = false) :
             m_key_matcher(std::forward<TKey>(key_matcher)),
             m_value_matcher(std::forward<TValue>(value_matcher)),
diff --git a/include/osmium/thread/function_wrapper.hpp b/include/osmium/thread/function_wrapper.hpp
@@ -87,8 +87,8 @@ namespace osmium {
 
             // Constructor must not be "explicit" for wrapper
             // to work seemlessly.
-            template <typename TFunction, typename X = typename std::enable_if<
-                !std::is_same<TFunction, function_wrapper>::value, void>::type>
+            template <typename TFunction, typename X = std::enable_if_t<
+                !std::is_same<TFunction, function_wrapper>::value, void>>
             // cppcheck-suppress noExplicitConstructor
             function_wrapper(TFunction&& f) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
                 impl(new impl_type<TFunction>(std::forward<TFunction>(f))) {
diff --git a/include/osmium/thread/pool.hpp b/include/osmium/thread/pool.hpp
@@ -225,7 +225,7 @@ namespace osmium {
 #else
             // For C++11 and C++14
             template <typename TFunction>
-            using submit_func_result_type = typename std::result_of<TFunction()>::type;
+            using submit_func_result_type = std::result_of_t<TFunction()>;
 #endif
 
             template <typename TFunction>
diff --git a/include/osmium/util/misc.hpp b/include/osmium/util/misc.hpp
@@ -69,7 +69,7 @@ namespace osmium {
         template <typename TReturn>
         inline TReturn str_to_int(const char* str) {
             static_assert(std::is_integral<TReturn>::value, "Must be integral type");
-            using r_type = typename std::conditional<std::is_unsigned<TReturn>::value, unsigned long long, long long>::type; // NOLINT(google-runtime-int)
+            using r_type = std::conditional_t<std::is_unsigned<TReturn>::value, unsigned long long, long long>; // NOLINT(google-runtime-int)
             assert(str);
             char* end = nullptr;
             const auto value = std::strtoll(str, &end, 10);
diff --git a/include/osmium/util/string_matcher.hpp b/include/osmium/util/string_matcher.hpp
@@ -419,8 +419,8 @@ namespace osmium {
          *                  equal, prefix, substring, regex or list.
          */
         // cppcheck-suppress noExplicitConstructor
-        template <typename TMatcher, typename X = typename std::enable_if<
-            std::is_base_of<matcher, TMatcher>::value, void>::type>
+        template <typename TMatcher, typename X = std::enable_if_t<
+            std::is_base_of<matcher, TMatcher>::value, void>>
         StringMatcher(TMatcher&& matcher) : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)
             m_matcher(std::forward<TMatcher>(matcher)) {
         }
diff --git a/include/osmium/visitor.hpp b/include/osmium/visitor.hpp
@@ -49,7 +49,7 @@ namespace osmium {
     namespace detail {
 
         template <typename T, typename U>
-        using ConstIfConst = typename std::conditional<std::is_const<T>::value, typename std::add_const<U>::type, U>::type;
+        using ConstIfConst = std::conditional_t<std::is_const<T>::value, std::add_const_t<U>, U>;
 
         template <typename THandler, typename TItem>
         inline void apply_item_impl(TItem& item, THandler&& handler) {
@@ -286,18 +286,18 @@ namespace osmium {
 
         // Is the class T derived from osmium::handler::Handler?
         template <typename T>
-        using is_handler = std::is_base_of<osmium::handler::Handler, typename std::remove_reference<T>::type>;
+        using is_handler = std::is_base_of<osmium::handler::Handler, std::remove_reference_t<T>>;
 
         // This is already a handler, use it as it is.
-        template <typename T, typename = typename std::enable_if<is_handler<T>::value>::type>
+        template <typename T, typename = std::enable_if_t<is_handler<T>::value>>
         T make_handler(T&& func) {
             return std::forward<T>(func);
         }
 
         // This is not a handler, but a functor. Wrap a handler around it.
-        template <typename T, typename = typename std::enable_if<!is_handler<T>::value>::type>
-        wrapper_handler<typename std::decay<T>::type> make_handler(T&& func) {
-            return wrapper_handler<typename std::decay<T>::type>(std::forward<T>(func));
+        template <typename T, typename = std::enable_if_t<!is_handler<T>::value>>
+        wrapper_handler<std::decay_t<T>> make_handler(T&& func) {
+            return wrapper_handler<std::decay_t<T>>(std::forward<T>(func));
         }
 
     } // namespace detail

Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ namespace osmium {`
`95`	`95`	`m_map.emplace_back(key, value);`
`96`	`96`	`}`
`97`	`97`
`98`		`- typename std::enable_if<std::is_same<TKey, TValue>::value>::type flip_in_place() {`
	`98`	`+ std::enable_if_t<std::is_same<TKey, TValue>::value> flip_in_place() {`
`99`	`99`	`for (auto& p : m_map) {`
`100`	`100`	`using std::swap;`
`101`	`101`	`swap(p.key, p.value);`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,7 @@ namespace osmium {`
`220`	`220`	`* The constructor is not declared "explicit" so that conversions`
`221`	`221`	`* like @code node.set_timestamp(123); @endcode work.`
`222`	`222`	`*/`
`223`		`- template <typename T, typename std::enable_if<std::is_integral<T>::value, int>::type = 0>`
	`223`	`+ template <typename T, typename std::enable_if_t<std::is_integral<T>::value, int> = 0>`
`224`	`224`	`constexpr Timestamp(T timestamp) noexcept : // NOLINT(google-explicit-constructor, hicpp-explicit-conversions)`
`225`	`225`	`m_timestamp(static_cast<uint32_t>(timestamp)) {`
`226`	`226`	`}`