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

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.
  */
 
 // This file defines six constexpr functions:
 //
-//   rtc::safe_cmp::Eq  // ==
-//   rtc::safe_cmp::Ne  // !=
-//   rtc::safe_cmp::Lt  // <
-//   rtc::safe_cmp::Le  // <=
-//   rtc::safe_cmp::Gt  // >
-//   rtc::safe_cmp::Ge  // >=
+//   rtc::SafeEq  // ==
+//   rtc::SafeNe  // !=
+//   rtc::SafeLt  // <
+//   rtc::SafeLe  // <=
+//   rtc::SafeGt  // >
+//   rtc::SafeGe  // >=
 //
 // They each accept two arguments of arbitrary types, and in almost all cases,
 // they simply call the appropriate comparison operator. However, if both
 // arguments are integers, they don't compare them using C++'s quirky rules,
 // but instead adhere to the true mathematical definitions. It is as if the
 // arguments were first converted to infinite-range signed integers, and then
 // compared, although of course nothing expensive like that actually takes
 // place. In practice, for signed/signed and unsigned/unsigned comparisons and
 // some mixed-signed comparisons with a compile-time constant, the overhead is
 // zero; in the remaining cases, it is just a few machine instructions (no
 // branches).
 
 #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;
 };
 template <>
@@ skipping 92 matching lines @@
 RTC_SAFECMP_MAKE_OP(GtOp, >)
 RTC_SAFECMP_MAKE_OP(GeOp, >=)
 #undef RTC_SAFECMP_MAKE_OP
 
 }  // namespace safe_cmp_impl
 
 #define RTC_SAFECMP_MAKE_FUN(name)                                            \
   template <typename T1, typename T2>                                         \
   constexpr                                                                   \
       typename std::enable_if<IsIntlike<T1>::value && IsIntlike<T2>::value,   \
-                              bool>::type                                     \
-      name(T1 a, T2 b) {                                                      \
+                              bool>::type Safe##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>                                         \
   constexpr                                                                   \
       typename std::enable_if<!IsIntlike<T1>::value || !IsIntlike<T2>::value, \
-                              bool>::type                                     \
-      name(const T1& a, const T2& b) {                                        \
+                              bool>::type Safe##name(const T1& a,             \
+                                                     const 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_