zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adds signed infinity to timestamps.

Browse Source 
Negative infinity is useful in comparisons as it represents a value
guaranteed to be less than any other timestamp. This avoid using
Timestamp::ms(0) to represent such a value or having to use optional
for the special case of first time execution.

To avoid ambiguity, Timestamp::Infinity is renamed to PlusInfinity.

Bug: webrtc:9709
Change-Id: Ib2debff91036e94d1dc903ec0c6faae30febde4e
Reviewed-on: https://webrtc-review.googlesource.com/79440
Commit-Queue: Sebastian Jansson <srte@webrtc.org>
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#24556}
This commit is contained in:
Sebastian Jansson
2018-09-04 17:32:36 +02:00
committed by Commit Bot
parent 376e1147e6
commit 9de4ef4b24
15 changed files with 130 additions and 72 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
api/units/time_delta_unittest.cc
View File

@ -74,6 +74,12 @@ TEST(TimeDeltaTest, IdentityChecks) {
EXPECT_TRUE(TimeDelta::ms(-kValue).IsFinite());
EXPECT_TRUE(TimeDelta::ms(kValue).IsFinite());
EXPECT_TRUE(TimeDelta::Zero().IsFinite());
EXPECT_TRUE(TimeDelta::PlusInfinity().IsPlusInfinity());
EXPECT_FALSE(TimeDelta::MinusInfinity().IsPlusInfinity());
EXPECT_TRUE(TimeDelta::MinusInfinity().IsMinusInfinity());
EXPECT_FALSE(TimeDelta::PlusInfinity().IsMinusInfinity());
}
TEST(TimeDeltaTest, ComparisonOperators) {

72
api/units/timestamp.h
View File

@ -36,9 +36,12 @@ constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
class Timestamp {
public:
Timestamp() = delete;
static constexpr Timestamp Infinity() {
static constexpr Timestamp PlusInfinity() {
return Timestamp(timestamp_impl::kPlusInfinityVal);
}
static constexpr Timestamp MinusInfinity() {
return Timestamp(timestamp_impl::kMinusInfinityVal);
}
template <int64_t seconds>
static constexpr Timestamp Seconds() {
static_assert(seconds >= 0, "");
@ -103,7 +106,9 @@ class Timestamp {
nullptr>
static Timestamp us(T microseconds) {
if (microseconds == std::numeric_limits<double>::infinity()) {
return Infinity();
return PlusInfinity();
} else if (microseconds == -std::numeric_limits<double>::infinity()) {
return MinusInfinity();
} else {
RTC_DCHECK(!std::isnan(microseconds));
RTC_DCHECK_GE(microseconds, 0);
@ -141,7 +146,10 @@ class Timestamp {
template <typename T>
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
us() const {
return IsInfinite() ? std::numeric_limits<T>::infinity() : microseconds_;
return IsPlusInfinity()
? std::numeric_limits<T>::infinity()
: IsMinusInfinity() ? -std::numeric_limits<T>::infinity()
: microseconds_;
}
constexpr int64_t seconds_or(int64_t fallback_value) const {
@ -154,25 +162,53 @@ class Timestamp {
return IsFinite() ? microseconds_ : fallback_value;
}
constexpr bool IsInfinite() const {
return microseconds_ == timestamp_impl::kPlusInfinityVal;
}
constexpr bool IsFinite() const { return !IsInfinite(); }
constexpr bool IsInfinite() const {
return microseconds_ == timedelta_impl::kPlusInfinityVal ||
microseconds_ == timedelta_impl::kMinusInfinityVal;
}
constexpr bool IsPlusInfinity() const {
return microseconds_ == timedelta_impl::kPlusInfinityVal;
}
constexpr bool IsMinusInfinity() const {
return microseconds_ == timedelta_impl::kMinusInfinityVal;
}
Timestamp operator+(const TimeDelta& other) const {
if (IsPlusInfinity() || other.IsPlusInfinity()) {
RTC_DCHECK(!IsMinusInfinity());
RTC_DCHECK(!other.IsMinusInfinity());
return PlusInfinity();
} else if (IsMinusInfinity() || other.IsMinusInfinity()) {
RTC_DCHECK(!IsPlusInfinity());
RTC_DCHECK(!other.IsPlusInfinity());
return MinusInfinity();
}
return Timestamp::us(us() + other.us());
}
Timestamp operator-(const TimeDelta& other) const {
if (IsPlusInfinity() || other.IsMinusInfinity()) {
RTC_DCHECK(!IsMinusInfinity());
RTC_DCHECK(!other.IsPlusInfinity());
return PlusInfinity();
} else if (IsMinusInfinity() || other.IsPlusInfinity()) {
RTC_DCHECK(!IsPlusInfinity());
RTC_DCHECK(!other.IsMinusInfinity());
return MinusInfinity();
}
return Timestamp::us(us() - other.us());
}
TimeDelta operator-(const Timestamp& other) const {
if (IsPlusInfinity() || other.IsMinusInfinity()) {
RTC_DCHECK(!IsMinusInfinity());
RTC_DCHECK(!other.IsPlusInfinity());
return TimeDelta::PlusInfinity();
} else if (IsMinusInfinity() || other.IsPlusInfinity()) {
RTC_DCHECK(!IsPlusInfinity());
RTC_DCHECK(!other.IsMinusInfinity());
return TimeDelta::MinusInfinity();
}
return TimeDelta::us(us() - other.us());
}
Timestamp operator-(const TimeDelta& delta) const {
RTC_DCHECK(!delta.IsPlusInfinity());
if (IsInfinite() || delta.IsMinusInfinity())
return Infinity();
return Timestamp::us(us() - delta.us());
}
Timestamp operator+(const TimeDelta& delta) const {
RTC_DCHECK(!delta.IsMinusInfinity());
if (IsInfinite() || delta.IsPlusInfinity())
return Infinity();
return Timestamp::us(us() + delta.us());
}
Timestamp& operator-=(const TimeDelta& other) {
*this = *this - other;
return *this;

43
api/units/timestamp_unittest.cc
View File

@ -15,7 +15,7 @@ namespace webrtc {
namespace test {
TEST(TimestampTest, ConstExpr) {
constexpr int64_t kValue = 12345;
constexpr Timestamp kTimestampInf = Timestamp::Infinity();
constexpr Timestamp kTimestampInf = Timestamp::PlusInfinity();
static_assert(kTimestampInf.IsInfinite(), "");
static_assert(kTimestampInf.ms_or(-1) == -1, "");
@ -55,20 +55,28 @@ TEST(TimestampTest, GetDifferentPrefix) {
TEST(TimestampTest, IdentityChecks) {
const int64_t kValue = 3000;
EXPECT_TRUE(Timestamp::Infinity().IsInfinite());
EXPECT_TRUE(Timestamp::PlusInfinity().IsInfinite());
EXPECT_TRUE(Timestamp::MinusInfinity().IsInfinite());
EXPECT_FALSE(Timestamp::ms(kValue).IsInfinite());
EXPECT_FALSE(Timestamp::Infinity().IsFinite());
EXPECT_FALSE(Timestamp::PlusInfinity().IsFinite());
EXPECT_FALSE(Timestamp::MinusInfinity().IsFinite());
EXPECT_TRUE(Timestamp::ms(kValue).IsFinite());
EXPECT_TRUE(Timestamp::PlusInfinity().IsPlusInfinity());
EXPECT_FALSE(Timestamp::MinusInfinity().IsPlusInfinity());
EXPECT_TRUE(Timestamp::MinusInfinity().IsMinusInfinity());
EXPECT_FALSE(Timestamp::PlusInfinity().IsMinusInfinity());
}
TEST(TimestampTest, ComparisonOperators) {
const int64_t kSmall = 450;
const int64_t kLarge = 451;
EXPECT_EQ(Timestamp::Infinity(), Timestamp::Infinity());
EXPECT_GE(Timestamp::Infinity(), Timestamp::Infinity());
EXPECT_GT(Timestamp::Infinity(), Timestamp::ms(kLarge));
EXPECT_EQ(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
EXPECT_GE(Timestamp::PlusInfinity(), Timestamp::PlusInfinity());
EXPECT_GT(Timestamp::PlusInfinity(), Timestamp::ms(kLarge));
EXPECT_EQ(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
EXPECT_LE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
EXPECT_GE(Timestamp::ms(kSmall), Timestamp::ms(kSmall));
@ -102,14 +110,21 @@ TEST(TimestampTest, ConvertsToAndFromDouble) {
EXPECT_EQ(Timestamp::us(kMicrosDouble).us(), kMicros);
const double kPlusInfinity = std::numeric_limits<double>::infinity();
const double kMinusInfinity = -kPlusInfinity;
EXPECT_EQ(Timestamp::Infinity().seconds<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::Infinity().ms<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::Infinity().us<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::PlusInfinity().seconds<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::MinusInfinity().seconds<double>(), kMinusInfinity);
EXPECT_EQ(Timestamp::PlusInfinity().ms<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::MinusInfinity().ms<double>(), kMinusInfinity);
EXPECT_EQ(Timestamp::PlusInfinity().us<double>(), kPlusInfinity);
EXPECT_EQ(Timestamp::MinusInfinity().us<double>(), kMinusInfinity);
EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsInfinite());
EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsInfinite());
EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsInfinite());
EXPECT_TRUE(Timestamp::seconds(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::seconds(kMinusInfinity).IsMinusInfinity());
EXPECT_TRUE(Timestamp::ms(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::ms(kMinusInfinity).IsMinusInfinity());
EXPECT_TRUE(Timestamp::us(kPlusInfinity).IsPlusInfinity());
EXPECT_TRUE(Timestamp::us(kMinusInfinity).IsMinusInfinity());
}
TEST(UnitConversionTest, TimestampAndTimeDeltaMath) {
@ -135,8 +150,8 @@ TEST(UnitConversionTest, InfinityOperations) {
const int64_t kValue = 267;
const Timestamp finite_time = Timestamp::ms(kValue);
const TimeDelta finite_delta = TimeDelta::ms(kValue);
EXPECT_TRUE((Timestamp::Infinity() + finite_delta).IsInfinite());
EXPECT_TRUE((Timestamp::Infinity() - finite_delta).IsInfinite());
EXPECT_TRUE((Timestamp::PlusInfinity() + finite_delta).IsInfinite());
EXPECT_TRUE((Timestamp::PlusInfinity() - finite_delta).IsInfinite());
EXPECT_TRUE((finite_time + TimeDelta::PlusInfinity()).IsInfinite());
EXPECT_TRUE((finite_time - TimeDelta::MinusInfinity()).IsInfinite());
}