Rename safe_cmp::{Eq,Ne,Lt,Le,Ge,Gt} to Safe{Eq,Ne,Lt,Le,Ge,Gt}

webrtc/base/safe_minmax.h

 /*
  *  Copyright 2017 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 124 matching lines @@
                 "");
 };
 
 // Specialization for when both types are integral.
 template <typename T1, typename T2>
 struct MType<T1, T2, true, true> {
   // The type with the lowest minimum value. In case of a tie, the type with
   // the lowest maximum value. In case that too is a tie, the types have the
   // same range, and we arbitrarily pick T1.
   using min_t = typename std::conditional<
-      safe_cmp::Lt(Limits<T1>::lowest, Limits<T2>::lowest),
+      SafeLt(Limits<T1>::lowest, Limits<T2>::lowest),
       T1,
       typename std::conditional<
-          safe_cmp::Gt(Limits<T1>::lowest, Limits<T2>::lowest),
+          SafeGt(Limits<T1>::lowest, Limits<T2>::lowest),
           T2,
-          typename std::conditional<safe_cmp::Le(Limits<T1>::max,
-                                                 Limits<T2>::max),
+          typename std::conditional<SafeLe(Limits<T1>::max, Limits<T2>::max),
                                     T1,
                                     T2>::type>::type>::type;
   static_assert(std::is_same<min_t, T1>::value ||
                     std::is_same<min_t, T2>::value,
                 "");
 
   // The type with the highest maximum value. In case of a tie, the types have
   // the same range (because in C++, integer types with the same maximum also
   // have the same minimum).
-  static_assert(safe_cmp::Ne(Limits<T1>::max, Limits<T2>::max) ||
-                    safe_cmp::Eq(Limits<T1>::lowest, Limits<T2>::lowest),
+  static_assert(SafeNe(Limits<T1>::max, Limits<T2>::max) ||
+                    SafeEq(Limits<T1>::lowest, Limits<T2>::lowest),
                 "integer types with the same max should have the same min");
   using max_t = typename std::
-      conditional<safe_cmp::Ge(Limits<T1>::max, Limits<T2>::max), T1, T2>::type;
+      conditional<SafeGe(Limits<T1>::max, Limits<T2>::max), T1, T2>::type;
   static_assert(std::is_same<max_t, T1>::value ||
                     std::is_same<max_t, T2>::value,
                 "");
 };
 
 // A dummy type that we pass around at compile time but never actually use.
 // Declared but not defined.
 struct DefaultType;
 
 // ::type is A, except we fall back to B if A is DefaultType. We static_assert
 // that the chosen type can hold all values that B can hold.
 template <typename A, typename B>
 struct TypeOr {
   using type = typename std::
       conditional<std::is_same<A, DefaultType>::value, B, A>::type;
-  static_assert(safe_cmp::Le(Limits<type>::lowest, Limits<B>::lowest) &&
-                    safe_cmp::Ge(Limits<type>::max, Limits<B>::max),
+  static_assert(SafeLe(Limits<type>::lowest, Limits<B>::lowest) &&
+                    SafeGe(Limits<type>::max, Limits<B>::max),
                 "The specified type isn't large enough");
   static_assert(IsIntlike<type>::value == IsIntlike<B>::value &&
                     std::is_floating_point<type>::value ==
                         std::is_floating_point<type>::value,
                 "float<->int conversions not allowed");
 };
 
 }  // namespace safe_minmax_impl
 
 template <
     typename R = safe_minmax_impl::DefaultType,
     typename T1 = safe_minmax_impl::DefaultType,
     typename T2 = safe_minmax_impl::DefaultType,
     typename R2 = typename safe_minmax_impl::TypeOr<
         R,
         typename safe_minmax_impl::MType<
             typename safe_minmax_impl::UnderlyingType<T1>::type,
             typename safe_minmax_impl::UnderlyingType<T2>::type>::min_t>::type>
 constexpr R2 SafeMin(T1 a, T2 b) {
   static_assert(IsIntlike<T1>::value || std::is_floating_point<T1>::value,
                 "The first argument must be integral or floating-point");
   static_assert(IsIntlike<T2>::value || std::is_floating_point<T2>::value,
                 "The second argument must be integral or floating-point");
-  return safe_cmp::Lt(a, b) ? static_cast<R2>(a) : static_cast<R2>(b);
+  return SafeLt(a, b) ? static_cast<R2>(a) : static_cast<R2>(b);
 }
 
 template <
     typename R = safe_minmax_impl::DefaultType,
     typename T1 = safe_minmax_impl::DefaultType,
     typename T2 = safe_minmax_impl::DefaultType,
     typename R2 = typename safe_minmax_impl::TypeOr<
         R,
         typename safe_minmax_impl::MType<
             typename safe_minmax_impl::UnderlyingType<T1>::type,
             typename safe_minmax_impl::UnderlyingType<T2>::type>::max_t>::type>
 constexpr R2 SafeMax(T1 a, T2 b) {
   static_assert(IsIntlike<T1>::value || std::is_floating_point<T1>::value,
                 "The first argument must be integral or floating-point");
   static_assert(IsIntlike<T2>::value || std::is_floating_point<T2>::value,
                 "The second argument must be integral or floating-point");
-  return safe_cmp::Gt(a, b) ? static_cast<R2>(a) : static_cast<R2>(b);
+  return SafeGt(a, b) ? static_cast<R2>(a) : static_cast<R2>(b);
 }
 
 namespace safe_minmax_impl {
 
 // Given three types T, L, and H, let ::type be a suitable return value for
 // SafeClamp(T, L, H). See the docs at the top of this file for details.
 template <typename T,
           typename L,
           typename H,
           bool int1 = IsIntlike<T>::value,
@@ skipping 24 matching lines @@
   // Is the given type an acceptable return type? (That is, can it represent
   // all possible return values, and is it no larger than the largest of the
   // input types?)
   template <typename A>
   struct AcceptableType {
    private:
     static constexpr bool not_too_large = sizeof(A) <= sizeof(L) ||
                                           sizeof(A) <= sizeof(H) ||
                                           sizeof(A) <= sizeof(T);
     static constexpr bool range_contained =
-        safe_cmp::Le(Limits<A>::lowest, r_min) &&
-        safe_cmp::Le(r_max, Limits<A>::max);
+        SafeLe(Limits<A>::lowest, r_min) && SafeLe(r_max, Limits<A>::max);
 
    public:
     static constexpr bool value = not_too_large && range_contained;
   };
 
   using best_signed_type = typename std::conditional<
       AcceptableType<int8_t>::value,
       int8_t,
       typename std::conditional<
           AcceptableType<int16_t>::value,
@@ skipping 40 matching lines @@
             typename safe_minmax_impl::UnderlyingType<L>::type,
             typename safe_minmax_impl::UnderlyingType<H>::type>::type>::type>
 R2 SafeClamp(T x, L min, H max) {
   static_assert(IsIntlike<H>::value || std::is_floating_point<H>::value,
                 "The first argument must be integral or floating-point");
   static_assert(IsIntlike<T>::value || std::is_floating_point<T>::value,
                 "The second argument must be integral or floating-point");
   static_assert(IsIntlike<L>::value || std::is_floating_point<L>::value,
                 "The third argument must be integral or floating-point");
   RTC_DCHECK_LE(min, max);
-  return safe_cmp::Le(x, min)
+  return SafeLe(x, min)
              ? static_cast<R2>(min)
-             : safe_cmp::Ge(x, max) ? static_cast<R2>(max) : static_cast<R2>(x);
+             : SafeGe(x, max) ? static_cast<R2>(max) : static_cast<R2>(x);
 }
 
 }  // namespace rtc
 
 #endif  // WEBRTC_BASE_SAFE_MINMAX_H_