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}
This commit is contained in:
kwiberg
Commit Bot
parent
001d00a79a
commit
93ecc5dad0
@ -99,7 +99,7 @@ namespace rtc {
|
||||
// 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 @@ std::string* MakeCheckOpString<std::string, std::string>(
|
||||
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); \
|
||||
|
||||
@ -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 @@ RTC_SAFECMP_MAKE_OP(GeOp, >=)
|
||||
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(Gt)
|
||||
RTC_SAFECMP_MAKE_FUN(Ge)
|
||||
#undef RTC_SAFECMP_MAKE_FUN
|
||||
|
||||
} // namespace safe_cmp
|
||||
} // namespace rtc
|
||||
|
||||
#endif // WEBRTC_BASE_SAFE_COMPARE_H_
|
||||
|
||||
@ -40,10 +40,10 @@ static const std::pair<int, int> p2(1, 2);
|
||||
// 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( int a) { return a < 17; }
|
||||
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 @@ TEST(SafeCmpTest, Enum) {
|
||||
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
|
||||
|
||||
@ -142,13 +142,12 @@ struct MType<T1, T2, true, true> {
|
||||
// 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 @@ struct MType<T1, T2, true, true> {
|
||||
// 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 @@ 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 ==
|
||||
@ -203,7 +202,7 @@ constexpr R2 SafeMin(T1 a, T2 b) {
|
||||
"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 @@ constexpr R2 SafeMax(T1 a, T2 b) {
|
||||
"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 @@ struct ClampType<T, L, H, true, true, true> {
|
||||
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 @@ R2 SafeClamp(T x, L min, H max) {
|
||||
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
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user