Move IsIntlike to type_traits.h

webrtc/base/safe_compare.h

 /*
  *  Copyright 2016 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 19 matching lines @@
 
 #ifndef WEBRTC_BASE_SAFE_COMPARE_H_
 #define WEBRTC_BASE_SAFE_COMPARE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <type_traits>
 #include <utility>
 
+#include "webrtc/base/type_traits.h"
+
 namespace rtc {
 namespace safe_cmp {
 
 namespace safe_cmp_impl {
 
 template <size_t N>
 struct LargerIntImpl : std::false_type {};
 template <>
 struct LargerIntImpl<sizeof(int8_t)> : std::true_type {
   using type = int16_t;
@@ skipping 88 matching lines @@
     }                                      \
   };
 RTC_SAFECMP_MAKE_OP(EqOp, ==)
 RTC_SAFECMP_MAKE_OP(NeOp, !=)
 RTC_SAFECMP_MAKE_OP(LtOp, <)
 RTC_SAFECMP_MAKE_OP(LeOp, <=)
 RTC_SAFECMP_MAKE_OP(GtOp, >)
 RTC_SAFECMP_MAKE_OP(GeOp, >=)
 #undef RTC_SAFECMP_MAKE_OP
 
-// Determines if the given type is an enum that converts implicitly to
-// an integral type.
-template <typename T>
-struct IsIntEnum {
- private:
-  // This overload is used if the type is an enum, and unary plus
-  // compiles and turns it into an integral type.
-  template <typename X,
-            typename std::enable_if<
-                std::is_enum<X>::value &&
-                std::is_integral<decltype(+std::declval<X>())>::value>::type* =
-                nullptr>
-  static int Test(int);
-
-  // Otherwise, this overload is used.
-  template <typename>
-  static char Test(...);
-
- public:
-  static constexpr bool value =
-      std::is_same<decltype(Test<typename std::remove_reference<T>::type>(0)),
-                   int>::value;
-};
-
-// Determines if the given type is integral, or an enum that
-// converts implicitly to an integral type.
-template <typename T>
-struct IsIntlike {
- private:
-  using X = typename std::remove_reference<T>::type;
-
- public:
-  static constexpr bool value =
-      std::is_integral<X>::value || IsIntEnum<X>::value;
-};
-
-namespace test_enum_intlike {
-
-enum E1 { e1 };
-enum { e2 };
-enum class E3 { e3 };
-struct S {};
-
-static_assert(IsIntEnum<E1>::value, "");
-static_assert(IsIntEnum<decltype(e2)>::value, "");
-static_assert(!IsIntEnum<E3>::value, "");
-static_assert(!IsIntEnum<int>::value, "");
-static_assert(!IsIntEnum<float>::value, "");
-static_assert(!IsIntEnum<S>::value, "");
-
-static_assert(IsIntlike<E1>::value, "");
-static_assert(IsIntlike<decltype(e2)>::value, "");
-static_assert(!IsIntlike<E3>::value, "");
-static_assert(IsIntlike<int>::value, "");
-static_assert(!IsIntlike<float>::value, "");
-static_assert(!IsIntlike<S>::value, "");
-
-}  // test_enum_intlike
 }  // namespace safe_cmp_impl
 
-#define RTC_SAFECMP_MAKE_FUN(name)                                      \
-  template <typename T1, typename T2,                                   \
-            typename std::enable_if<                                    \
-                safe_cmp_impl::IsIntlike<T1>::value &&                  \
-                safe_cmp_impl::IsIntlike<T2>::value>::type* = nullptr>  \
-  inline bool name(T1 a, T2 b) {                                        \
-    /* Unary plus here turns enums into real integral types. */         \
-    return safe_cmp_impl::Cmp<safe_cmp_impl::name##Op>(+a, +b);         \
-  }                                                                     \
-  template <typename T1, typename T2,                                   \
-            typename std::enable_if<                                    \
-                !safe_cmp_impl::IsIntlike<T1>::value ||                 \
-                !safe_cmp_impl::IsIntlike<T2>::value>::type* = nullptr> \
-  inline bool name(T1&& a, T2&& b) {                                    \
-    return safe_cmp_impl::name##Op::Op(a, b);                           \
+#define RTC_SAFECMP_MAKE_FUN(name)                                           \
+  template <typename T1, typename T2,                                        \
+            typename std::enable_if<IsIntlike<T1>::value &&                  \
+                                    IsIntlike<T2>::value>::type* = nullptr>  \
+  inline bool name(T1 a, T2 b) {                                             \
+    /* Unary plus here turns enums into real integral types. */              \
+    return safe_cmp_impl::Cmp<safe_cmp_impl::name##Op>(+a, +b);              \
+  }                                                                          \
+  template <typename T1, typename T2,                                        \
+            typename std::enable_if<!IsIntlike<T1>::value ||                 \
+                                    !IsIntlike<T2>::value>::type* = nullptr> \
+  inline bool name(T1&& a, T2&& b) {                                         \
+    return safe_cmp_impl::name##Op::Op(a, b);                                \
   }
 RTC_SAFECMP_MAKE_FUN(Eq)
 RTC_SAFECMP_MAKE_FUN(Ne)
 RTC_SAFECMP_MAKE_FUN(Lt)
 RTC_SAFECMP_MAKE_FUN(Le)
 RTC_SAFECMP_MAKE_FUN(Gt)
 RTC_SAFECMP_MAKE_FUN(Ge)
 #undef RTC_SAFECMP_MAKE_FUN
 
 }  // namespace safe_cmp
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_SAFE_COMPARE_H_