Adds signed infinity to timestamps.
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}diff --git a/api/units/time_delta_unittest.cc b/api/units/time_delta_unittest.cc
index e5906bf..bf8bbce 100644
--- a/api/units/time_delta_unittest.cc
+++ b/api/units/time_delta_unittest.cc
@@ -74,6 +74,12 @@
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) {
diff --git a/api/units/timestamp.h b/api/units/timestamp.h
index d7e6a8d..0298f5d 100644
--- a/api/units/timestamp.h
+++ b/api/units/timestamp.h
@@ -36,9 +36,12 @@
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 @@
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 @@
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 @@
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;
diff --git a/api/units/timestamp_unittest.cc b/api/units/timestamp_unittest.cc
index ff0c79e..6c2d1ee 100644
--- a/api/units/timestamp_unittest.cc
+++ b/api/units/timestamp_unittest.cc
@@ -15,7 +15,7 @@
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, 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 @@
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 @@
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());
}