Rename safe_cmp::{Eq,Ne,Lt,Le,Ge,Gt} to Safe{Eq,Ne,Lt,Le,Ge,Gt}
For consistency with SafeMin(), SafeMax(), and SafeClamp(). And so that we avoid introducing a namespace.
BUG=webrtc:7459
Review-Url: https://codereview.webrtc.org/2802423002
Cr-Commit-Position: refs/heads/master@{#18756}
diff --git a/webrtc/base/checks.h b/webrtc/base/checks.h
index c15a08c..b86fb15 100644
--- a/webrtc/base/checks.h
+++ b/webrtc/base/checks.h
@@ -99,7 +99,7 @@
// values of the same types as |a| and |b| can't be compared with the given
// operation, and that would evaluate |a| and |b| if evaluated.
#define RTC_EAT_STREAM_PARAMETERS_OP(op, a, b) \
- RTC_EAT_STREAM_PARAMETERS(((void)rtc::safe_cmp::op(a, b)))
+ RTC_EAT_STREAM_PARAMETERS(((void)rtc::Safe##op(a, b)))
// RTC_CHECK dies with a fatal error if condition is not true. It is *not*
// controlled by NDEBUG or anything else, so the check will be executed
@@ -162,13 +162,13 @@
template <class t1, class t2> \
inline std::string* Check##name##Impl(const t1& v1, const t2& v2, \
const char* names) { \
- if (rtc::safe_cmp::name(v1, v2)) \
+ if (rtc::Safe##name(v1, v2)) \
return nullptr; \
else \
return rtc::MakeCheckOpString(v1, v2, names); \
} \
inline std::string* Check##name##Impl(int v1, int v2, const char* names) { \
- if (rtc::safe_cmp::name(v1, v2)) \
+ if (rtc::Safe##name(v1, v2)) \
return nullptr; \
else \
return rtc::MakeCheckOpString(v1, v2, names); \
diff --git a/webrtc/base/safe_compare.h b/webrtc/base/safe_compare.h
index 0350d5d..a57f082 100644
--- a/webrtc/base/safe_compare.h
+++ b/webrtc/base/safe_compare.h
@@ -10,12 +10,12 @@
// 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
@@ -40,7 +40,6 @@
#include "webrtc/base/type_traits.h"
namespace rtc {
-namespace safe_cmp {
namespace safe_cmp_impl {
@@ -153,16 +152,15 @@
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)
@@ -173,7 +171,6 @@
RTC_SAFECMP_MAKE_FUN(Ge)
#undef RTC_SAFECMP_MAKE_FUN
-} // namespace safe_cmp
} // namespace rtc
#endif // WEBRTC_BASE_SAFE_COMPARE_H_
diff --git a/webrtc/base/safe_compare_unittest.cc b/webrtc/base/safe_compare_unittest.cc
index 9663164..1ebb722 100644
--- a/webrtc/base/safe_compare_unittest.cc
+++ b/webrtc/base/safe_compare_unittest.cc
@@ -40,10 +40,10 @@
// arithmetic and logic instructions (but no extra control flow instructions).
bool TestLessThanRef( int a, int b) { return a < b; }
bool TestLessThanRef( unsigned a, unsigned b) { return a < b; }
-bool TestLessThanSafe( int a, int b) { return safe_cmp::Lt(a, b); }
-bool TestLessThanSafe(unsigned a, unsigned b) { return safe_cmp::Lt(a, b); }
-bool TestLessThanSafe(unsigned a, int b) { return safe_cmp::Lt(a, b); }
-bool TestLessThanSafe( int a, unsigned b) { return safe_cmp::Lt(a, b); }
+bool TestLessThanSafe( int a, int b) { return SafeLt(a, b); }
+bool TestLessThanSafe(unsigned a, unsigned b) { return SafeLt(a, b); }
+bool TestLessThanSafe(unsigned a, int b) { return SafeLt(a, b); }
+bool TestLessThanSafe( int a, unsigned b) { return SafeLt(a, b); }
// For these, we expect the *Ref and *Safe functions to result in identical
// code, except for the ones that compare a signed variable with an unsigned
@@ -54,326 +54,326 @@
bool TestLessThan17Ref( unsigned a) { return a < 17; }
bool TestLessThan17uRef( int a) { return static_cast<unsigned>(a) < 17u; }
bool TestLessThan17uRef( unsigned a) { return a < 17u; }
-bool TestLessThan17Safe( int a) { return safe_cmp::Lt(a, 17); }
-bool TestLessThan17Safe( unsigned a) { return safe_cmp::Lt(a, 17); }
-bool TestLessThan17uSafe( int a) { return safe_cmp::Lt(a, 17u); }
-bool TestLessThan17uSafe(unsigned a) { return safe_cmp::Lt(a, 17u); }
+bool TestLessThan17Safe( int a) { return SafeLt(a, 17); }
+bool TestLessThan17Safe( unsigned a) { return SafeLt(a, 17); }
+bool TestLessThan17uSafe( int a) { return SafeLt(a, 17u); }
+bool TestLessThan17uSafe(unsigned a) { return SafeLt(a, 17u); }
// Cases where we can't convert to a larger signed type.
-bool TestLessThanMax( intmax_t a, uintmax_t b) { return safe_cmp::Lt(a, b); }
-bool TestLessThanMax(uintmax_t a, intmax_t b) { return safe_cmp::Lt(a, b); }
-bool TestLessThanMax17u( intmax_t a) { return safe_cmp::Lt(a, uintmax_t{17}); }
-bool TestLessThanMax17( uintmax_t a) { return safe_cmp::Lt(a, intmax_t{17}); }
+bool TestLessThanMax( intmax_t a, uintmax_t b) { return SafeLt(a, b); }
+bool TestLessThanMax(uintmax_t a, intmax_t b) { return SafeLt(a, b); }
+bool TestLessThanMax17u( intmax_t a) { return SafeLt(a, uintmax_t{17}); }
+bool TestLessThanMax17( uintmax_t a) { return SafeLt(a, intmax_t{17}); }
// Cases where the compiler should be able to compute the result at compile
// time.
-bool TestLessThanConst1() { return safe_cmp::Lt( -1, 1); }
-bool TestLessThanConst2() { return safe_cmp::Lt( m1, umax); }
-bool TestLessThanConst3() { return safe_cmp::Lt(umax, imin); }
-bool TestLessThanConst4(unsigned a) { return safe_cmp::Lt( a, -1); }
-bool TestLessThanConst5(unsigned a) { return safe_cmp::Lt(-1, a); }
-bool TestLessThanConst6(unsigned a) { return safe_cmp::Lt( a, a); }
+bool TestLessThanConst1() { return SafeLt( -1, 1); }
+bool TestLessThanConst2() { return SafeLt( m1, umax); }
+bool TestLessThanConst3() { return SafeLt(umax, imin); }
+bool TestLessThanConst4(unsigned a) { return SafeLt( a, -1); }
+bool TestLessThanConst5(unsigned a) { return SafeLt(-1, a); }
+bool TestLessThanConst6(unsigned a) { return SafeLt( a, a); }
// clang-format on
TEST(SafeCmpTest, Eq) {
- static_assert(!safe_cmp::Eq(-1, 2), "");
- static_assert(!safe_cmp::Eq(-1, 2u), "");
- static_assert(!safe_cmp::Eq(2, -1), "");
- static_assert(!safe_cmp::Eq(2u, -1), "");
+ static_assert(!SafeEq(-1, 2), "");
+ static_assert(!SafeEq(-1, 2u), "");
+ static_assert(!SafeEq(2, -1), "");
+ static_assert(!SafeEq(2u, -1), "");
- static_assert(!safe_cmp::Eq(1, 2), "");
- static_assert(!safe_cmp::Eq(1, 2u), "");
- static_assert(!safe_cmp::Eq(1u, 2), "");
- static_assert(!safe_cmp::Eq(1u, 2u), "");
- static_assert(!safe_cmp::Eq(2, 1), "");
- static_assert(!safe_cmp::Eq(2, 1u), "");
- static_assert(!safe_cmp::Eq(2u, 1), "");
- static_assert(!safe_cmp::Eq(2u, 1u), "");
+ static_assert(!SafeEq(1, 2), "");
+ static_assert(!SafeEq(1, 2u), "");
+ static_assert(!SafeEq(1u, 2), "");
+ static_assert(!SafeEq(1u, 2u), "");
+ static_assert(!SafeEq(2, 1), "");
+ static_assert(!SafeEq(2, 1u), "");
+ static_assert(!SafeEq(2u, 1), "");
+ static_assert(!SafeEq(2u, 1u), "");
- static_assert(safe_cmp::Eq(2, 2), "");
- static_assert(safe_cmp::Eq(2, 2u), "");
- static_assert(safe_cmp::Eq(2u, 2), "");
- static_assert(safe_cmp::Eq(2u, 2u), "");
+ static_assert(SafeEq(2, 2), "");
+ static_assert(SafeEq(2, 2u), "");
+ static_assert(SafeEq(2u, 2), "");
+ static_assert(SafeEq(2u, 2u), "");
- static_assert(safe_cmp::Eq(imin, imin), "");
- static_assert(!safe_cmp::Eq(imin, umax), "");
- static_assert(!safe_cmp::Eq(umax, imin), "");
- static_assert(safe_cmp::Eq(umax, umax), "");
+ static_assert(SafeEq(imin, imin), "");
+ static_assert(!SafeEq(imin, umax), "");
+ static_assert(!SafeEq(umax, imin), "");
+ static_assert(SafeEq(umax, umax), "");
- static_assert(safe_cmp::Eq(m1, m1), "");
- static_assert(!safe_cmp::Eq(m1, umax), "");
- static_assert(!safe_cmp::Eq(umax, m1), "");
- static_assert(safe_cmp::Eq(umax, umax), "");
+ static_assert(SafeEq(m1, m1), "");
+ static_assert(!SafeEq(m1, umax), "");
+ static_assert(!SafeEq(umax, m1), "");
+ static_assert(SafeEq(umax, umax), "");
- static_assert(!safe_cmp::Eq(1, 2), "");
- static_assert(!safe_cmp::Eq(1, 2.0), "");
- static_assert(!safe_cmp::Eq(1.0, 2), "");
- static_assert(!safe_cmp::Eq(1.0, 2.0), "");
- static_assert(!safe_cmp::Eq(2, 1), "");
- static_assert(!safe_cmp::Eq(2, 1.0), "");
- static_assert(!safe_cmp::Eq(2.0, 1), "");
- static_assert(!safe_cmp::Eq(2.0, 1.0), "");
+ static_assert(!SafeEq(1, 2), "");
+ static_assert(!SafeEq(1, 2.0), "");
+ static_assert(!SafeEq(1.0, 2), "");
+ static_assert(!SafeEq(1.0, 2.0), "");
+ static_assert(!SafeEq(2, 1), "");
+ static_assert(!SafeEq(2, 1.0), "");
+ static_assert(!SafeEq(2.0, 1), "");
+ static_assert(!SafeEq(2.0, 1.0), "");
- static_assert(safe_cmp::Eq(2, 2), "");
- static_assert(safe_cmp::Eq(2, 2.0), "");
- static_assert(safe_cmp::Eq(2.0, 2), "");
- static_assert(safe_cmp::Eq(2.0, 2.0), "");
+ static_assert(SafeEq(2, 2), "");
+ static_assert(SafeEq(2, 2.0), "");
+ static_assert(SafeEq(2.0, 2), "");
+ static_assert(SafeEq(2.0, 2.0), "");
- EXPECT_TRUE(safe_cmp::Eq(p1, p1));
- EXPECT_FALSE(safe_cmp::Eq(p1, p2));
- EXPECT_FALSE(safe_cmp::Eq(p2, p1));
- EXPECT_TRUE(safe_cmp::Eq(p2, p2));
+ EXPECT_TRUE(SafeEq(p1, p1));
+ EXPECT_FALSE(SafeEq(p1, p2));
+ EXPECT_FALSE(SafeEq(p2, p1));
+ EXPECT_TRUE(SafeEq(p2, p2));
}
TEST(SafeCmpTest, Ne) {
- static_assert(safe_cmp::Ne(-1, 2), "");
- static_assert(safe_cmp::Ne(-1, 2u), "");
- static_assert(safe_cmp::Ne(2, -1), "");
- static_assert(safe_cmp::Ne(2u, -1), "");
+ static_assert(SafeNe(-1, 2), "");
+ static_assert(SafeNe(-1, 2u), "");
+ static_assert(SafeNe(2, -1), "");
+ static_assert(SafeNe(2u, -1), "");
- static_assert(safe_cmp::Ne(1, 2), "");
- static_assert(safe_cmp::Ne(1, 2u), "");
- static_assert(safe_cmp::Ne(1u, 2), "");
- static_assert(safe_cmp::Ne(1u, 2u), "");
- static_assert(safe_cmp::Ne(2, 1), "");
- static_assert(safe_cmp::Ne(2, 1u), "");
- static_assert(safe_cmp::Ne(2u, 1), "");
- static_assert(safe_cmp::Ne(2u, 1u), "");
+ static_assert(SafeNe(1, 2), "");
+ static_assert(SafeNe(1, 2u), "");
+ static_assert(SafeNe(1u, 2), "");
+ static_assert(SafeNe(1u, 2u), "");
+ static_assert(SafeNe(2, 1), "");
+ static_assert(SafeNe(2, 1u), "");
+ static_assert(SafeNe(2u, 1), "");
+ static_assert(SafeNe(2u, 1u), "");
- static_assert(!safe_cmp::Ne(2, 2), "");
- static_assert(!safe_cmp::Ne(2, 2u), "");
- static_assert(!safe_cmp::Ne(2u, 2), "");
- static_assert(!safe_cmp::Ne(2u, 2u), "");
+ static_assert(!SafeNe(2, 2), "");
+ static_assert(!SafeNe(2, 2u), "");
+ static_assert(!SafeNe(2u, 2), "");
+ static_assert(!SafeNe(2u, 2u), "");
- static_assert(!safe_cmp::Ne(imin, imin), "");
- static_assert(safe_cmp::Ne(imin, umax), "");
- static_assert(safe_cmp::Ne(umax, imin), "");
- static_assert(!safe_cmp::Ne(umax, umax), "");
+ static_assert(!SafeNe(imin, imin), "");
+ static_assert(SafeNe(imin, umax), "");
+ static_assert(SafeNe(umax, imin), "");
+ static_assert(!SafeNe(umax, umax), "");
- static_assert(!safe_cmp::Ne(m1, m1), "");
- static_assert(safe_cmp::Ne(m1, umax), "");
- static_assert(safe_cmp::Ne(umax, m1), "");
- static_assert(!safe_cmp::Ne(umax, umax), "");
+ static_assert(!SafeNe(m1, m1), "");
+ static_assert(SafeNe(m1, umax), "");
+ static_assert(SafeNe(umax, m1), "");
+ static_assert(!SafeNe(umax, umax), "");
- static_assert(safe_cmp::Ne(1, 2), "");
- static_assert(safe_cmp::Ne(1, 2.0), "");
- static_assert(safe_cmp::Ne(1.0, 2), "");
- static_assert(safe_cmp::Ne(1.0, 2.0), "");
- static_assert(safe_cmp::Ne(2, 1), "");
- static_assert(safe_cmp::Ne(2, 1.0), "");
- static_assert(safe_cmp::Ne(2.0, 1), "");
- static_assert(safe_cmp::Ne(2.0, 1.0), "");
+ static_assert(SafeNe(1, 2), "");
+ static_assert(SafeNe(1, 2.0), "");
+ static_assert(SafeNe(1.0, 2), "");
+ static_assert(SafeNe(1.0, 2.0), "");
+ static_assert(SafeNe(2, 1), "");
+ static_assert(SafeNe(2, 1.0), "");
+ static_assert(SafeNe(2.0, 1), "");
+ static_assert(SafeNe(2.0, 1.0), "");
- static_assert(!safe_cmp::Ne(2, 2), "");
- static_assert(!safe_cmp::Ne(2, 2.0), "");
- static_assert(!safe_cmp::Ne(2.0, 2), "");
- static_assert(!safe_cmp::Ne(2.0, 2.0), "");
+ static_assert(!SafeNe(2, 2), "");
+ static_assert(!SafeNe(2, 2.0), "");
+ static_assert(!SafeNe(2.0, 2), "");
+ static_assert(!SafeNe(2.0, 2.0), "");
- EXPECT_FALSE(safe_cmp::Ne(p1, p1));
- EXPECT_TRUE(safe_cmp::Ne(p1, p2));
- EXPECT_TRUE(safe_cmp::Ne(p2, p1));
- EXPECT_FALSE(safe_cmp::Ne(p2, p2));
+ EXPECT_FALSE(SafeNe(p1, p1));
+ EXPECT_TRUE(SafeNe(p1, p2));
+ EXPECT_TRUE(SafeNe(p2, p1));
+ EXPECT_FALSE(SafeNe(p2, p2));
}
TEST(SafeCmpTest, Lt) {
- static_assert(safe_cmp::Lt(-1, 2), "");
- static_assert(safe_cmp::Lt(-1, 2u), "");
- static_assert(!safe_cmp::Lt(2, -1), "");
- static_assert(!safe_cmp::Lt(2u, -1), "");
+ static_assert(SafeLt(-1, 2), "");
+ static_assert(SafeLt(-1, 2u), "");
+ static_assert(!SafeLt(2, -1), "");
+ static_assert(!SafeLt(2u, -1), "");
- static_assert(safe_cmp::Lt(1, 2), "");
- static_assert(safe_cmp::Lt(1, 2u), "");
- static_assert(safe_cmp::Lt(1u, 2), "");
- static_assert(safe_cmp::Lt(1u, 2u), "");
- static_assert(!safe_cmp::Lt(2, 1), "");
- static_assert(!safe_cmp::Lt(2, 1u), "");
- static_assert(!safe_cmp::Lt(2u, 1), "");
- static_assert(!safe_cmp::Lt(2u, 1u), "");
+ static_assert(SafeLt(1, 2), "");
+ static_assert(SafeLt(1, 2u), "");
+ static_assert(SafeLt(1u, 2), "");
+ static_assert(SafeLt(1u, 2u), "");
+ static_assert(!SafeLt(2, 1), "");
+ static_assert(!SafeLt(2, 1u), "");
+ static_assert(!SafeLt(2u, 1), "");
+ static_assert(!SafeLt(2u, 1u), "");
- static_assert(!safe_cmp::Lt(2, 2), "");
- static_assert(!safe_cmp::Lt(2, 2u), "");
- static_assert(!safe_cmp::Lt(2u, 2), "");
- static_assert(!safe_cmp::Lt(2u, 2u), "");
+ static_assert(!SafeLt(2, 2), "");
+ static_assert(!SafeLt(2, 2u), "");
+ static_assert(!SafeLt(2u, 2), "");
+ static_assert(!SafeLt(2u, 2u), "");
- static_assert(!safe_cmp::Lt(imin, imin), "");
- static_assert(safe_cmp::Lt(imin, umax), "");
- static_assert(!safe_cmp::Lt(umax, imin), "");
- static_assert(!safe_cmp::Lt(umax, umax), "");
+ static_assert(!SafeLt(imin, imin), "");
+ static_assert(SafeLt(imin, umax), "");
+ static_assert(!SafeLt(umax, imin), "");
+ static_assert(!SafeLt(umax, umax), "");
- static_assert(!safe_cmp::Lt(m1, m1), "");
- static_assert(safe_cmp::Lt(m1, umax), "");
- static_assert(!safe_cmp::Lt(umax, m1), "");
- static_assert(!safe_cmp::Lt(umax, umax), "");
+ static_assert(!SafeLt(m1, m1), "");
+ static_assert(SafeLt(m1, umax), "");
+ static_assert(!SafeLt(umax, m1), "");
+ static_assert(!SafeLt(umax, umax), "");
- static_assert(safe_cmp::Lt(1, 2), "");
- static_assert(safe_cmp::Lt(1, 2.0), "");
- static_assert(safe_cmp::Lt(1.0, 2), "");
- static_assert(safe_cmp::Lt(1.0, 2.0), "");
- static_assert(!safe_cmp::Lt(2, 1), "");
- static_assert(!safe_cmp::Lt(2, 1.0), "");
- static_assert(!safe_cmp::Lt(2.0, 1), "");
- static_assert(!safe_cmp::Lt(2.0, 1.0), "");
+ static_assert(SafeLt(1, 2), "");
+ static_assert(SafeLt(1, 2.0), "");
+ static_assert(SafeLt(1.0, 2), "");
+ static_assert(SafeLt(1.0, 2.0), "");
+ static_assert(!SafeLt(2, 1), "");
+ static_assert(!SafeLt(2, 1.0), "");
+ static_assert(!SafeLt(2.0, 1), "");
+ static_assert(!SafeLt(2.0, 1.0), "");
- static_assert(!safe_cmp::Lt(2, 2), "");
- static_assert(!safe_cmp::Lt(2, 2.0), "");
- static_assert(!safe_cmp::Lt(2.0, 2), "");
- static_assert(!safe_cmp::Lt(2.0, 2.0), "");
+ static_assert(!SafeLt(2, 2), "");
+ static_assert(!SafeLt(2, 2.0), "");
+ static_assert(!SafeLt(2.0, 2), "");
+ static_assert(!SafeLt(2.0, 2.0), "");
- EXPECT_FALSE(safe_cmp::Lt(p1, p1));
- EXPECT_TRUE(safe_cmp::Lt(p1, p2));
- EXPECT_FALSE(safe_cmp::Lt(p2, p1));
- EXPECT_FALSE(safe_cmp::Lt(p2, p2));
+ EXPECT_FALSE(SafeLt(p1, p1));
+ EXPECT_TRUE(SafeLt(p1, p2));
+ EXPECT_FALSE(SafeLt(p2, p1));
+ EXPECT_FALSE(SafeLt(p2, p2));
}
TEST(SafeCmpTest, Le) {
- static_assert(safe_cmp::Le(-1, 2), "");
- static_assert(safe_cmp::Le(-1, 2u), "");
- static_assert(!safe_cmp::Le(2, -1), "");
- static_assert(!safe_cmp::Le(2u, -1), "");
+ static_assert(SafeLe(-1, 2), "");
+ static_assert(SafeLe(-1, 2u), "");
+ static_assert(!SafeLe(2, -1), "");
+ static_assert(!SafeLe(2u, -1), "");
- static_assert(safe_cmp::Le(1, 2), "");
- static_assert(safe_cmp::Le(1, 2u), "");
- static_assert(safe_cmp::Le(1u, 2), "");
- static_assert(safe_cmp::Le(1u, 2u), "");
- static_assert(!safe_cmp::Le(2, 1), "");
- static_assert(!safe_cmp::Le(2, 1u), "");
- static_assert(!safe_cmp::Le(2u, 1), "");
- static_assert(!safe_cmp::Le(2u, 1u), "");
+ static_assert(SafeLe(1, 2), "");
+ static_assert(SafeLe(1, 2u), "");
+ static_assert(SafeLe(1u, 2), "");
+ static_assert(SafeLe(1u, 2u), "");
+ static_assert(!SafeLe(2, 1), "");
+ static_assert(!SafeLe(2, 1u), "");
+ static_assert(!SafeLe(2u, 1), "");
+ static_assert(!SafeLe(2u, 1u), "");
- static_assert(safe_cmp::Le(2, 2), "");
- static_assert(safe_cmp::Le(2, 2u), "");
- static_assert(safe_cmp::Le(2u, 2), "");
- static_assert(safe_cmp::Le(2u, 2u), "");
+ static_assert(SafeLe(2, 2), "");
+ static_assert(SafeLe(2, 2u), "");
+ static_assert(SafeLe(2u, 2), "");
+ static_assert(SafeLe(2u, 2u), "");
- static_assert(safe_cmp::Le(imin, imin), "");
- static_assert(safe_cmp::Le(imin, umax), "");
- static_assert(!safe_cmp::Le(umax, imin), "");
- static_assert(safe_cmp::Le(umax, umax), "");
+ static_assert(SafeLe(imin, imin), "");
+ static_assert(SafeLe(imin, umax), "");
+ static_assert(!SafeLe(umax, imin), "");
+ static_assert(SafeLe(umax, umax), "");
- static_assert(safe_cmp::Le(m1, m1), "");
- static_assert(safe_cmp::Le(m1, umax), "");
- static_assert(!safe_cmp::Le(umax, m1), "");
- static_assert(safe_cmp::Le(umax, umax), "");
+ static_assert(SafeLe(m1, m1), "");
+ static_assert(SafeLe(m1, umax), "");
+ static_assert(!SafeLe(umax, m1), "");
+ static_assert(SafeLe(umax, umax), "");
- static_assert(safe_cmp::Le(1, 2), "");
- static_assert(safe_cmp::Le(1, 2.0), "");
- static_assert(safe_cmp::Le(1.0, 2), "");
- static_assert(safe_cmp::Le(1.0, 2.0), "");
- static_assert(!safe_cmp::Le(2, 1), "");
- static_assert(!safe_cmp::Le(2, 1.0), "");
- static_assert(!safe_cmp::Le(2.0, 1), "");
- static_assert(!safe_cmp::Le(2.0, 1.0), "");
+ static_assert(SafeLe(1, 2), "");
+ static_assert(SafeLe(1, 2.0), "");
+ static_assert(SafeLe(1.0, 2), "");
+ static_assert(SafeLe(1.0, 2.0), "");
+ static_assert(!SafeLe(2, 1), "");
+ static_assert(!SafeLe(2, 1.0), "");
+ static_assert(!SafeLe(2.0, 1), "");
+ static_assert(!SafeLe(2.0, 1.0), "");
- static_assert(safe_cmp::Le(2, 2), "");
- static_assert(safe_cmp::Le(2, 2.0), "");
- static_assert(safe_cmp::Le(2.0, 2), "");
- static_assert(safe_cmp::Le(2.0, 2.0), "");
+ static_assert(SafeLe(2, 2), "");
+ static_assert(SafeLe(2, 2.0), "");
+ static_assert(SafeLe(2.0, 2), "");
+ static_assert(SafeLe(2.0, 2.0), "");
- EXPECT_TRUE(safe_cmp::Le(p1, p1));
- EXPECT_TRUE(safe_cmp::Le(p1, p2));
- EXPECT_FALSE(safe_cmp::Le(p2, p1));
- EXPECT_TRUE(safe_cmp::Le(p2, p2));
+ EXPECT_TRUE(SafeLe(p1, p1));
+ EXPECT_TRUE(SafeLe(p1, p2));
+ EXPECT_FALSE(SafeLe(p2, p1));
+ EXPECT_TRUE(SafeLe(p2, p2));
}
TEST(SafeCmpTest, Gt) {
- static_assert(!safe_cmp::Gt(-1, 2), "");
- static_assert(!safe_cmp::Gt(-1, 2u), "");
- static_assert(safe_cmp::Gt(2, -1), "");
- static_assert(safe_cmp::Gt(2u, -1), "");
+ static_assert(!SafeGt(-1, 2), "");
+ static_assert(!SafeGt(-1, 2u), "");
+ static_assert(SafeGt(2, -1), "");
+ static_assert(SafeGt(2u, -1), "");
- static_assert(!safe_cmp::Gt(1, 2), "");
- static_assert(!safe_cmp::Gt(1, 2u), "");
- static_assert(!safe_cmp::Gt(1u, 2), "");
- static_assert(!safe_cmp::Gt(1u, 2u), "");
- static_assert(safe_cmp::Gt(2, 1), "");
- static_assert(safe_cmp::Gt(2, 1u), "");
- static_assert(safe_cmp::Gt(2u, 1), "");
- static_assert(safe_cmp::Gt(2u, 1u), "");
+ static_assert(!SafeGt(1, 2), "");
+ static_assert(!SafeGt(1, 2u), "");
+ static_assert(!SafeGt(1u, 2), "");
+ static_assert(!SafeGt(1u, 2u), "");
+ static_assert(SafeGt(2, 1), "");
+ static_assert(SafeGt(2, 1u), "");
+ static_assert(SafeGt(2u, 1), "");
+ static_assert(SafeGt(2u, 1u), "");
- static_assert(!safe_cmp::Gt(2, 2), "");
- static_assert(!safe_cmp::Gt(2, 2u), "");
- static_assert(!safe_cmp::Gt(2u, 2), "");
- static_assert(!safe_cmp::Gt(2u, 2u), "");
+ static_assert(!SafeGt(2, 2), "");
+ static_assert(!SafeGt(2, 2u), "");
+ static_assert(!SafeGt(2u, 2), "");
+ static_assert(!SafeGt(2u, 2u), "");
- static_assert(!safe_cmp::Gt(imin, imin), "");
- static_assert(!safe_cmp::Gt(imin, umax), "");
- static_assert(safe_cmp::Gt(umax, imin), "");
- static_assert(!safe_cmp::Gt(umax, umax), "");
+ static_assert(!SafeGt(imin, imin), "");
+ static_assert(!SafeGt(imin, umax), "");
+ static_assert(SafeGt(umax, imin), "");
+ static_assert(!SafeGt(umax, umax), "");
- static_assert(!safe_cmp::Gt(m1, m1), "");
- static_assert(!safe_cmp::Gt(m1, umax), "");
- static_assert(safe_cmp::Gt(umax, m1), "");
- static_assert(!safe_cmp::Gt(umax, umax), "");
+ static_assert(!SafeGt(m1, m1), "");
+ static_assert(!SafeGt(m1, umax), "");
+ static_assert(SafeGt(umax, m1), "");
+ static_assert(!SafeGt(umax, umax), "");
- static_assert(!safe_cmp::Gt(1, 2), "");
- static_assert(!safe_cmp::Gt(1, 2.0), "");
- static_assert(!safe_cmp::Gt(1.0, 2), "");
- static_assert(!safe_cmp::Gt(1.0, 2.0), "");
- static_assert(safe_cmp::Gt(2, 1), "");
- static_assert(safe_cmp::Gt(2, 1.0), "");
- static_assert(safe_cmp::Gt(2.0, 1), "");
- static_assert(safe_cmp::Gt(2.0, 1.0), "");
+ static_assert(!SafeGt(1, 2), "");
+ static_assert(!SafeGt(1, 2.0), "");
+ static_assert(!SafeGt(1.0, 2), "");
+ static_assert(!SafeGt(1.0, 2.0), "");
+ static_assert(SafeGt(2, 1), "");
+ static_assert(SafeGt(2, 1.0), "");
+ static_assert(SafeGt(2.0, 1), "");
+ static_assert(SafeGt(2.0, 1.0), "");
- static_assert(!safe_cmp::Gt(2, 2), "");
- static_assert(!safe_cmp::Gt(2, 2.0), "");
- static_assert(!safe_cmp::Gt(2.0, 2), "");
- static_assert(!safe_cmp::Gt(2.0, 2.0), "");
+ static_assert(!SafeGt(2, 2), "");
+ static_assert(!SafeGt(2, 2.0), "");
+ static_assert(!SafeGt(2.0, 2), "");
+ static_assert(!SafeGt(2.0, 2.0), "");
- EXPECT_FALSE(safe_cmp::Gt(p1, p1));
- EXPECT_FALSE(safe_cmp::Gt(p1, p2));
- EXPECT_TRUE(safe_cmp::Gt(p2, p1));
- EXPECT_FALSE(safe_cmp::Gt(p2, p2));
+ EXPECT_FALSE(SafeGt(p1, p1));
+ EXPECT_FALSE(SafeGt(p1, p2));
+ EXPECT_TRUE(SafeGt(p2, p1));
+ EXPECT_FALSE(SafeGt(p2, p2));
}
TEST(SafeCmpTest, Ge) {
- static_assert(!safe_cmp::Ge(-1, 2), "");
- static_assert(!safe_cmp::Ge(-1, 2u), "");
- static_assert(safe_cmp::Ge(2, -1), "");
- static_assert(safe_cmp::Ge(2u, -1), "");
+ static_assert(!SafeGe(-1, 2), "");
+ static_assert(!SafeGe(-1, 2u), "");
+ static_assert(SafeGe(2, -1), "");
+ static_assert(SafeGe(2u, -1), "");
- static_assert(!safe_cmp::Ge(1, 2), "");
- static_assert(!safe_cmp::Ge(1, 2u), "");
- static_assert(!safe_cmp::Ge(1u, 2), "");
- static_assert(!safe_cmp::Ge(1u, 2u), "");
- static_assert(safe_cmp::Ge(2, 1), "");
- static_assert(safe_cmp::Ge(2, 1u), "");
- static_assert(safe_cmp::Ge(2u, 1), "");
- static_assert(safe_cmp::Ge(2u, 1u), "");
+ static_assert(!SafeGe(1, 2), "");
+ static_assert(!SafeGe(1, 2u), "");
+ static_assert(!SafeGe(1u, 2), "");
+ static_assert(!SafeGe(1u, 2u), "");
+ static_assert(SafeGe(2, 1), "");
+ static_assert(SafeGe(2, 1u), "");
+ static_assert(SafeGe(2u, 1), "");
+ static_assert(SafeGe(2u, 1u), "");
- static_assert(safe_cmp::Ge(2, 2), "");
- static_assert(safe_cmp::Ge(2, 2u), "");
- static_assert(safe_cmp::Ge(2u, 2), "");
- static_assert(safe_cmp::Ge(2u, 2u), "");
+ static_assert(SafeGe(2, 2), "");
+ static_assert(SafeGe(2, 2u), "");
+ static_assert(SafeGe(2u, 2), "");
+ static_assert(SafeGe(2u, 2u), "");
- static_assert(safe_cmp::Ge(imin, imin), "");
- static_assert(!safe_cmp::Ge(imin, umax), "");
- static_assert(safe_cmp::Ge(umax, imin), "");
- static_assert(safe_cmp::Ge(umax, umax), "");
+ static_assert(SafeGe(imin, imin), "");
+ static_assert(!SafeGe(imin, umax), "");
+ static_assert(SafeGe(umax, imin), "");
+ static_assert(SafeGe(umax, umax), "");
- static_assert(safe_cmp::Ge(m1, m1), "");
- static_assert(!safe_cmp::Ge(m1, umax), "");
- static_assert(safe_cmp::Ge(umax, m1), "");
- static_assert(safe_cmp::Ge(umax, umax), "");
+ static_assert(SafeGe(m1, m1), "");
+ static_assert(!SafeGe(m1, umax), "");
+ static_assert(SafeGe(umax, m1), "");
+ static_assert(SafeGe(umax, umax), "");
- static_assert(!safe_cmp::Ge(1, 2), "");
- static_assert(!safe_cmp::Ge(1, 2.0), "");
- static_assert(!safe_cmp::Ge(1.0, 2), "");
- static_assert(!safe_cmp::Ge(1.0, 2.0), "");
- static_assert(safe_cmp::Ge(2, 1), "");
- static_assert(safe_cmp::Ge(2, 1.0), "");
- static_assert(safe_cmp::Ge(2.0, 1), "");
- static_assert(safe_cmp::Ge(2.0, 1.0), "");
+ static_assert(!SafeGe(1, 2), "");
+ static_assert(!SafeGe(1, 2.0), "");
+ static_assert(!SafeGe(1.0, 2), "");
+ static_assert(!SafeGe(1.0, 2.0), "");
+ static_assert(SafeGe(2, 1), "");
+ static_assert(SafeGe(2, 1.0), "");
+ static_assert(SafeGe(2.0, 1), "");
+ static_assert(SafeGe(2.0, 1.0), "");
- static_assert(safe_cmp::Ge(2, 2), "");
- static_assert(safe_cmp::Ge(2, 2.0), "");
- static_assert(safe_cmp::Ge(2.0, 2), "");
- static_assert(safe_cmp::Ge(2.0, 2.0), "");
+ static_assert(SafeGe(2, 2), "");
+ static_assert(SafeGe(2, 2.0), "");
+ static_assert(SafeGe(2.0, 2), "");
+ static_assert(SafeGe(2.0, 2.0), "");
- EXPECT_TRUE(safe_cmp::Ge(p1, p1));
- EXPECT_FALSE(safe_cmp::Ge(p1, p2));
- EXPECT_TRUE(safe_cmp::Ge(p2, p1));
- EXPECT_TRUE(safe_cmp::Ge(p2, p2));
+ EXPECT_TRUE(SafeGe(p1, p1));
+ EXPECT_FALSE(SafeGe(p1, p2));
+ EXPECT_TRUE(SafeGe(p2, p1));
+ EXPECT_TRUE(SafeGe(p2, p2));
}
TEST(SafeCmpTest, Enum) {
@@ -381,14 +381,14 @@
enum { e2 = 13 };
enum E3 : unsigned { e3 = 13 };
enum : unsigned { e4 = 13 };
- static_assert(safe_cmp::Eq(13, e1), "");
- static_assert(safe_cmp::Eq(13u, e1), "");
- static_assert(safe_cmp::Eq(13, e2), "");
- static_assert(safe_cmp::Eq(13u, e2), "");
- static_assert(safe_cmp::Eq(13, e3), "");
- static_assert(safe_cmp::Eq(13u, e3), "");
- static_assert(safe_cmp::Eq(13, e4), "");
- static_assert(safe_cmp::Eq(13u, e4), "");
+ static_assert(SafeEq(13, e1), "");
+ static_assert(SafeEq(13u, e1), "");
+ static_assert(SafeEq(13, e2), "");
+ static_assert(SafeEq(13u, e2), "");
+ static_assert(SafeEq(13, e3), "");
+ static_assert(SafeEq(13u, e3), "");
+ static_assert(SafeEq(13, e4), "");
+ static_assert(SafeEq(13u, e4), "");
}
} // namespace rtc
diff --git a/webrtc/base/safe_minmax.h b/webrtc/base/safe_minmax.h
index 5d6a7d0..bf1cf43 100644
--- a/webrtc/base/safe_minmax.h
+++ b/webrtc/base/safe_minmax.h
@@ -142,13 +142,12 @@
// 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 ||
@@ -158,11 +157,11 @@
// 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,
"");
@@ -178,8 +177,8 @@
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 ==
@@ -203,7 +202,7 @@
"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 <
@@ -220,7 +219,7 @@
"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 {
@@ -265,8 +264,7 @@
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;
@@ -327,9 +325,9 @@
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
