Adds shared base class for data units.
This reduces code duplication and ensures common behavior between the unit classes. Bug: webrtc:9709 Change-Id: I9529ef10b3f538355f53250a2b67c6b4e250cce8 Reviewed-on: https://webrtc-review.googlesource.com/c/110901 Commit-Queue: Sebastian Jansson <srte@webrtc.org> Reviewed-by: Karl Wiberg <kwiberg@webrtc.org> Cr-Commit-Position: refs/heads/master@{#25690}
This commit is contained in:
Sebastian Jansson
committed by
Commit Bot
Commit Bot
parent
d474672dcd
commit
72bba625d5
@ -19,8 +19,8 @@ rtc_source_set("data_rate") {
|
||||
":data_size",
|
||||
":time_delta",
|
||||
"../../rtc_base:checks",
|
||||
"../../rtc_base:safe_conversions",
|
||||
"../../rtc_base:stringutils",
|
||||
"../../rtc_base/units:unit_base",
|
||||
]
|
||||
}
|
||||
|
||||
@ -33,8 +33,8 @@ rtc_source_set("data_size") {
|
||||
|
||||
deps = [
|
||||
"../../rtc_base:checks",
|
||||
"../../rtc_base:safe_conversions",
|
||||
"../../rtc_base:stringutils",
|
||||
"../../rtc_base/units:unit_base",
|
||||
]
|
||||
}
|
||||
|
||||
@ -47,8 +47,8 @@ rtc_source_set("time_delta") {
|
||||
|
||||
deps = [
|
||||
"../../rtc_base:checks",
|
||||
"../../rtc_base:safe_conversions",
|
||||
"../../rtc_base:stringutils",
|
||||
"../../rtc_base/units:unit_base",
|
||||
]
|
||||
}
|
||||
|
||||
@ -62,8 +62,8 @@ rtc_source_set("timestamp") {
|
||||
deps = [
|
||||
":time_delta",
|
||||
"../../rtc_base:checks",
|
||||
"../../rtc_base:safe_conversions",
|
||||
"../../rtc_base:stringutils",
|
||||
"../../rtc_base/units:unit_base",
|
||||
]
|
||||
}
|
||||
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
std::string ToString(const DataRate& value) {
|
||||
std::string ToString(DataRate value) {
|
||||
char buf[64];
|
||||
rtc::SimpleStringBuilder sb(buf);
|
||||
if (value.IsInfinite()) {
|
||||
|
||||
@ -15,9 +15,6 @@
|
||||
#include <ostream> // no-presubmit-check TODO(webrtc:8982)
|
||||
#endif // UNIT_TEST
|
||||
|
||||
#include <stdint.h>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
@ -25,12 +22,10 @@
|
||||
#include "api/units/data_size.h"
|
||||
#include "api/units/time_delta.h"
|
||||
#include "rtc_base/checks.h"
|
||||
#include "rtc_base/numerics/safe_conversions.h"
|
||||
#include "rtc_base/units/unit_base.h"
|
||||
|
||||
namespace webrtc {
|
||||
namespace data_rate_impl {
|
||||
constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
|
||||
|
||||
inline int64_t Microbits(const DataSize& size) {
|
||||
constexpr int64_t kMaxBeforeConversion =
|
||||
std::numeric_limits<int64_t>::max() / 8000000;
|
||||
@ -43,191 +38,64 @@ inline int64_t Microbits(const DataSize& size) {
|
||||
// DataRate is a class that represents a given data rate. This can be used to
|
||||
// represent bandwidth, encoding bitrate, etc. The internal storage is bits per
|
||||
// second (bps).
|
||||
class DataRate {
|
||||
class DataRate final : public rtc_units_impl::RelativeUnit<DataRate> {
|
||||
public:
|
||||
DataRate() = delete;
|
||||
static constexpr DataRate Zero() { return DataRate(0); }
|
||||
static constexpr DataRate Infinity() {
|
||||
return DataRate(data_rate_impl::kPlusInfinityVal);
|
||||
}
|
||||
static constexpr DataRate Infinity() { return PlusInfinity(); }
|
||||
template <int64_t bps>
|
||||
static constexpr DataRate BitsPerSec() {
|
||||
static_assert(bps >= 0, "");
|
||||
static_assert(bps < data_rate_impl::kPlusInfinityVal, "");
|
||||
return DataRate(bps);
|
||||
return FromStaticValue<bps>();
|
||||
}
|
||||
template <int64_t kbps>
|
||||
static constexpr DataRate KilobitsPerSec() {
|
||||
static_assert(kbps >= 0, "");
|
||||
static_assert(kbps < data_rate_impl::kPlusInfinityVal / 1000, "");
|
||||
return DataRate(kbps * 1000);
|
||||
}
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
|
||||
static DataRate bps(T bits_per_second) {
|
||||
RTC_DCHECK_GE(bits_per_second, 0);
|
||||
RTC_DCHECK_LT(bits_per_second, data_rate_impl::kPlusInfinityVal);
|
||||
return DataRate(rtc::dchecked_cast<int64_t>(bits_per_second));
|
||||
}
|
||||
template <
|
||||
typename T,
|
||||
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
|
||||
static DataRate kbps(T kilobits_per_sec) {
|
||||
RTC_DCHECK_GE(kilobits_per_sec, 0);
|
||||
RTC_DCHECK_LT(kilobits_per_sec, data_rate_impl::kPlusInfinityVal / 1000);
|
||||
return DataRate::bps(rtc::dchecked_cast<int64_t>(kilobits_per_sec) * 1000);
|
||||
}
|
||||
|
||||
template <typename T,
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type* =
|
||||
nullptr>
|
||||
static DataRate bps(T bits_per_second) {
|
||||
if (bits_per_second == std::numeric_limits<T>::infinity()) {
|
||||
return Infinity();
|
||||
} else {
|
||||
RTC_DCHECK(!std::isnan(bits_per_second));
|
||||
RTC_DCHECK_GE(bits_per_second, 0);
|
||||
RTC_DCHECK_LT(bits_per_second, data_rate_impl::kPlusInfinityVal);
|
||||
return DataRate(rtc::dchecked_cast<int64_t>(bits_per_second));
|
||||
}
|
||||
}
|
||||
template <typename T,
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type* =
|
||||
nullptr>
|
||||
static DataRate kbps(T kilobits_per_sec) {
|
||||
return DataRate::bps(kilobits_per_sec * 1e3);
|
||||
}
|
||||
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type bps() const {
|
||||
RTC_DCHECK(IsFinite());
|
||||
return rtc::dchecked_cast<T>(bits_per_sec_);
|
||||
}
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type kbps() const {
|
||||
RTC_DCHECK(IsFinite());
|
||||
return rtc::dchecked_cast<T>(UnsafeKilobitsPerSec());
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
typename std::enable_if<std::is_floating_point<T>::value,
|
||||
T>::type constexpr bps() const {
|
||||
return IsInfinite() ? std::numeric_limits<T>::infinity() : bits_per_sec_;
|
||||
return FromStaticFraction<kbps, 1000>();
|
||||
}
|
||||
template <typename T>
|
||||
typename std::enable_if<std::is_floating_point<T>::value,
|
||||
T>::type constexpr kbps() const {
|
||||
return bps<T>() * 1e-3;
|
||||
static constexpr DataRate bps(T bits_per_second) {
|
||||
return FromValue(bits_per_second);
|
||||
}
|
||||
template <typename T>
|
||||
static constexpr DataRate kbps(T kilobits_per_sec) {
|
||||
return FromFraction<1000>(kilobits_per_sec);
|
||||
}
|
||||
template <typename T = int64_t>
|
||||
constexpr T bps() const {
|
||||
return ToValue<T>();
|
||||
}
|
||||
template <typename T = int64_t>
|
||||
T kbps() const {
|
||||
return ToFraction<1000, T>();
|
||||
}
|
||||
|
||||
constexpr int64_t bps_or(int64_t fallback_value) const {
|
||||
return IsFinite() ? bits_per_sec_ : fallback_value;
|
||||
return ToValueOr(fallback_value);
|
||||
}
|
||||
constexpr int64_t kbps_or(int64_t fallback_value) const {
|
||||
return IsFinite() ? UnsafeKilobitsPerSec() : fallback_value;
|
||||
}
|
||||
|
||||
constexpr bool IsZero() const { return bits_per_sec_ == 0; }
|
||||
constexpr bool IsInfinite() const {
|
||||
return bits_per_sec_ == data_rate_impl::kPlusInfinityVal;
|
||||
}
|
||||
constexpr bool IsFinite() const { return !IsInfinite(); }
|
||||
DataRate Clamped(DataRate min_rate, DataRate max_rate) const {
|
||||
return std::max(min_rate, std::min(*this, max_rate));
|
||||
}
|
||||
void Clamp(DataRate min_rate, DataRate max_rate) {
|
||||
*this = Clamped(min_rate, max_rate);
|
||||
}
|
||||
DataRate operator-(const DataRate& other) const {
|
||||
return DataRate::bps(bps() - other.bps());
|
||||
}
|
||||
DataRate operator+(const DataRate& other) const {
|
||||
return DataRate::bps(bps() + other.bps());
|
||||
}
|
||||
DataRate& operator-=(const DataRate& other) {
|
||||
*this = *this - other;
|
||||
return *this;
|
||||
}
|
||||
DataRate& operator+=(const DataRate& other) {
|
||||
*this = *this + other;
|
||||
return *this;
|
||||
}
|
||||
constexpr double operator/(const DataRate& other) const {
|
||||
return bps<double>() / other.bps<double>();
|
||||
}
|
||||
constexpr bool operator==(const DataRate& other) const {
|
||||
return bits_per_sec_ == other.bits_per_sec_;
|
||||
}
|
||||
constexpr bool operator!=(const DataRate& other) const {
|
||||
return bits_per_sec_ != other.bits_per_sec_;
|
||||
}
|
||||
constexpr bool operator<=(const DataRate& other) const {
|
||||
return bits_per_sec_ <= other.bits_per_sec_;
|
||||
}
|
||||
constexpr bool operator>=(const DataRate& other) const {
|
||||
return bits_per_sec_ >= other.bits_per_sec_;
|
||||
}
|
||||
constexpr bool operator>(const DataRate& other) const {
|
||||
return bits_per_sec_ > other.bits_per_sec_;
|
||||
}
|
||||
constexpr bool operator<(const DataRate& other) const {
|
||||
return bits_per_sec_ < other.bits_per_sec_;
|
||||
return ToFractionOr<1000>(fallback_value);
|
||||
}
|
||||
|
||||
private:
|
||||
// Bits per second used internally to simplify debugging by making the value
|
||||
// more recognizable.
|
||||
explicit constexpr DataRate(int64_t bits_per_second)
|
||||
: bits_per_sec_(bits_per_second) {}
|
||||
constexpr int64_t UnsafeKilobitsPerSec() const {
|
||||
return (bits_per_sec_ + 500) / 1000;
|
||||
}
|
||||
int64_t bits_per_sec_;
|
||||
friend class rtc_units_impl::UnitBase<DataRate>;
|
||||
using RelativeUnit::RelativeUnit;
|
||||
static constexpr bool one_sided = true;
|
||||
};
|
||||
|
||||
inline DataRate operator*(const DataRate& rate, const double& scalar) {
|
||||
return DataRate::bps(std::round(rate.bps() * scalar));
|
||||
}
|
||||
inline DataRate operator*(const double& scalar, const DataRate& rate) {
|
||||
return rate * scalar;
|
||||
}
|
||||
inline DataRate operator*(const DataRate& rate, const int64_t& scalar) {
|
||||
return DataRate::bps(rate.bps() * scalar);
|
||||
}
|
||||
inline DataRate operator*(const int64_t& scalar, const DataRate& rate) {
|
||||
return rate * scalar;
|
||||
}
|
||||
inline DataRate operator*(const DataRate& rate, const int32_t& scalar) {
|
||||
return DataRate::bps(rate.bps() * scalar);
|
||||
}
|
||||
inline DataRate operator*(const int32_t& scalar, const DataRate& rate) {
|
||||
return rate * scalar;
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
typename std::enable_if<std::is_arithmetic<T>::value, DataRate>::type operator/(
|
||||
const DataRate& rate,
|
||||
const T& scalar) {
|
||||
return DataRate::bps(rate.bps<double>() / scalar);
|
||||
}
|
||||
|
||||
inline DataRate operator/(const DataSize& size, const TimeDelta& duration) {
|
||||
inline DataRate operator/(const DataSize size, const TimeDelta duration) {
|
||||
return DataRate::bps(data_rate_impl::Microbits(size) / duration.us());
|
||||
}
|
||||
inline TimeDelta operator/(const DataSize& size, const DataRate& rate) {
|
||||
inline TimeDelta operator/(const DataSize size, const DataRate rate) {
|
||||
return TimeDelta::us(data_rate_impl::Microbits(size) / rate.bps());
|
||||
}
|
||||
inline DataSize operator*(const DataRate& rate, const TimeDelta& duration) {
|
||||
inline DataSize operator*(const DataRate rate, const TimeDelta duration) {
|
||||
int64_t microbits = rate.bps() * duration.us();
|
||||
return DataSize::bytes((microbits + 4000000) / 8000000);
|
||||
}
|
||||
inline DataSize operator*(const TimeDelta& duration, const DataRate& rate) {
|
||||
inline DataSize operator*(const TimeDelta duration, const DataRate rate) {
|
||||
return rate * duration;
|
||||
}
|
||||
|
||||
std::string ToString(const DataRate& value);
|
||||
std::string ToString(DataRate value);
|
||||
|
||||
#ifdef UNIT_TEST
|
||||
inline std::ostream& operator<<( // no-presubmit-check TODO(webrtc:8982)
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
std::string ToString(const DataSize& value) {
|
||||
std::string ToString(DataSize value) {
|
||||
char buf[64];
|
||||
rtc::SimpleStringBuilder sb(buf);
|
||||
if (value.IsInfinite()) {
|
||||
|
||||
@ -15,143 +15,44 @@
|
||||
#include <ostream> // no-presubmit-check TODO(webrtc:8982)
|
||||
#endif // UNIT_TEST
|
||||
|
||||
#include <stdint.h>
|
||||
#include <cmath>
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
|
||||
#include "rtc_base/checks.h"
|
||||
#include "rtc_base/numerics/safe_conversions.h"
|
||||
#include "rtc_base/units/unit_base.h"
|
||||
|
||||
namespace webrtc {
|
||||
namespace data_size_impl {
|
||||
constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
|
||||
} // namespace data_size_impl
|
||||
|
||||
// DataSize is a class represeting a count of bytes.
|
||||
class DataSize {
|
||||
class DataSize final : public rtc_units_impl::RelativeUnit<DataSize> {
|
||||
public:
|
||||
DataSize() = delete;
|
||||
static constexpr DataSize Zero() { return DataSize(0); }
|
||||
static constexpr DataSize Infinity() {
|
||||
return DataSize(data_size_impl::kPlusInfinityVal);
|
||||
}
|
||||
static constexpr DataSize Infinity() { return PlusInfinity(); }
|
||||
template <int64_t bytes>
|
||||
static constexpr DataSize Bytes() {
|
||||
static_assert(bytes >= 0, "");
|
||||
static_assert(bytes < data_size_impl::kPlusInfinityVal, "");
|
||||
return DataSize(bytes);
|
||||
return FromStaticValue<bytes>();
|
||||
}
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
|
||||
typename std::enable_if<std::is_arithmetic<T>::value>::type* = nullptr>
|
||||
static DataSize bytes(T bytes) {
|
||||
RTC_DCHECK_GE(bytes, 0);
|
||||
RTC_DCHECK_LT(bytes, data_size_impl::kPlusInfinityVal);
|
||||
return DataSize(rtc::dchecked_cast<int64_t>(bytes));
|
||||
return FromValue(bytes);
|
||||
}
|
||||
|
||||
template <typename T,
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type* =
|
||||
nullptr>
|
||||
static DataSize bytes(T bytes) {
|
||||
if (bytes == std::numeric_limits<T>::infinity()) {
|
||||
return Infinity();
|
||||
} else {
|
||||
RTC_DCHECK(!std::isnan(bytes));
|
||||
RTC_DCHECK_GE(bytes, 0);
|
||||
RTC_DCHECK_LT(bytes, data_size_impl::kPlusInfinityVal);
|
||||
return DataSize(rtc::dchecked_cast<int64_t>(bytes));
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type bytes() const {
|
||||
RTC_DCHECK(IsFinite());
|
||||
return rtc::dchecked_cast<T>(bytes_);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
|
||||
bytes() const {
|
||||
return IsInfinite() ? std::numeric_limits<T>::infinity() : bytes_;
|
||||
typename std::enable_if<std::is_arithmetic<T>::value, T>::type bytes() const {
|
||||
return ToValue<T>();
|
||||
}
|
||||
|
||||
constexpr int64_t bytes_or(int64_t fallback_value) const {
|
||||
return IsFinite() ? bytes_ : fallback_value;
|
||||
}
|
||||
|
||||
constexpr bool IsZero() const { return bytes_ == 0; }
|
||||
constexpr bool IsInfinite() const {
|
||||
return bytes_ == data_size_impl::kPlusInfinityVal;
|
||||
}
|
||||
constexpr bool IsFinite() const { return !IsInfinite(); }
|
||||
DataSize operator-(const DataSize& other) const {
|
||||
return DataSize::bytes(bytes() - other.bytes());
|
||||
}
|
||||
DataSize operator+(const DataSize& other) const {
|
||||
return DataSize::bytes(bytes() + other.bytes());
|
||||
}
|
||||
DataSize& operator-=(const DataSize& other) {
|
||||
*this = *this - other;
|
||||
return *this;
|
||||
}
|
||||
DataSize& operator+=(const DataSize& other) {
|
||||
*this = *this + other;
|
||||
return *this;
|
||||
}
|
||||
constexpr double operator/(const DataSize& other) const {
|
||||
return bytes<double>() / other.bytes<double>();
|
||||
}
|
||||
constexpr bool operator==(const DataSize& other) const {
|
||||
return bytes_ == other.bytes_;
|
||||
}
|
||||
constexpr bool operator!=(const DataSize& other) const {
|
||||
return bytes_ != other.bytes_;
|
||||
}
|
||||
constexpr bool operator<=(const DataSize& other) const {
|
||||
return bytes_ <= other.bytes_;
|
||||
}
|
||||
constexpr bool operator>=(const DataSize& other) const {
|
||||
return bytes_ >= other.bytes_;
|
||||
}
|
||||
constexpr bool operator>(const DataSize& other) const {
|
||||
return bytes_ > other.bytes_;
|
||||
}
|
||||
constexpr bool operator<(const DataSize& other) const {
|
||||
return bytes_ < other.bytes_;
|
||||
return ToValueOr(fallback_value);
|
||||
}
|
||||
|
||||
private:
|
||||
explicit constexpr DataSize(int64_t bytes) : bytes_(bytes) {}
|
||||
int64_t bytes_;
|
||||
friend class rtc_units_impl::UnitBase<DataSize>;
|
||||
using RelativeUnit::RelativeUnit;
|
||||
static constexpr bool one_sided = true;
|
||||
};
|
||||
|
||||
inline DataSize operator*(const DataSize& size, const double& scalar) {
|
||||
return DataSize::bytes(std::round(size.bytes() * scalar));
|
||||
}
|
||||
inline DataSize operator*(const double& scalar, const DataSize& size) {
|
||||
return size * scalar;
|
||||
}
|
||||
inline DataSize operator*(const DataSize& size, const int64_t& scalar) {
|
||||
return DataSize::bytes(size.bytes() * scalar);
|
||||
}
|
||||
inline DataSize operator*(const int64_t& scalar, const DataSize& size) {
|
||||
return size * scalar;
|
||||
}
|
||||
inline DataSize operator*(const DataSize& size, const int32_t& scalar) {
|
||||
return DataSize::bytes(size.bytes() * scalar);
|
||||
}
|
||||
inline DataSize operator*(const int32_t& scalar, const DataSize& size) {
|
||||
return size * scalar;
|
||||
}
|
||||
inline DataSize operator/(const DataSize& size, const int64_t& scalar) {
|
||||
return DataSize::bytes(size.bytes() / scalar);
|
||||
}
|
||||
|
||||
std::string ToString(const DataSize& value);
|
||||
std::string ToString(DataSize value);
|
||||
|
||||
#ifdef UNIT_TEST
|
||||
inline std::ostream& operator<<( // no-presubmit-check TODO(webrtc:8982)
|
||||
|
||||
@ -14,7 +14,7 @@
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
std::string ToString(const TimeDelta& value) {
|
||||
std::string ToString(TimeDelta value) {
|
||||
char buf[64];
|
||||
rtc::SimpleStringBuilder sb(buf);
|
||||
if (value.IsPlusInfinity()) {
|
||||
|
||||
@ -15,23 +15,13 @@
|
||||
#include <ostream> // no-presubmit-check TODO(webrtc:8982)
|
||||
#endif // UNIT_TEST
|
||||
|
||||
#include <stdint.h>
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
|
||||
#include "rtc_base/checks.h"
|
||||
#include "rtc_base/numerics/safe_conversions.h"
|
||||
#include "rtc_base/units/unit_base.h"
|
||||
|
||||
namespace webrtc {
|
||||
namespace timedelta_impl {
|
||||
constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
|
||||
constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
|
||||
} // namespace timedelta_impl
|
||||
|
||||
// TimeDelta represents the difference between two timestamps. Commonly this can
|
||||
// be a duration. However since two Timestamps are not guaranteed to have the
|
||||
// same epoch (they might come from different computers, making exact
|
||||
@ -39,251 +29,69 @@ constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
|
||||
// undefined. To simplify usage, it can be constructed and converted to
|
||||
// different units, specifically seconds (s), milliseconds (ms) and
|
||||
// microseconds (us).
|
||||
class TimeDelta {
|
||||
class TimeDelta final : public rtc_units_impl::RelativeUnit<TimeDelta> {
|
||||
public:
|
||||
TimeDelta() = delete;
|
||||
static constexpr TimeDelta Zero() { return TimeDelta(0); }
|
||||
static constexpr TimeDelta PlusInfinity() {
|
||||
return TimeDelta(timedelta_impl::kPlusInfinityVal);
|
||||
}
|
||||
static constexpr TimeDelta MinusInfinity() {
|
||||
return TimeDelta(timedelta_impl::kMinusInfinityVal);
|
||||
}
|
||||
template <int64_t seconds>
|
||||
static constexpr TimeDelta Seconds() {
|
||||
static_assert(seconds > timedelta_impl::kMinusInfinityVal / 1000000, "");
|
||||
static_assert(seconds < timedelta_impl::kPlusInfinityVal / 1000000, "");
|
||||
return TimeDelta(seconds * 1000000);
|
||||
return FromStaticFraction<seconds, 1000000>();
|
||||
}
|
||||
template <int64_t ms>
|
||||
static constexpr TimeDelta Millis() {
|
||||
static_assert(ms > timedelta_impl::kMinusInfinityVal / 1000, "");
|
||||
static_assert(ms < timedelta_impl::kPlusInfinityVal / 1000, "");
|
||||
return TimeDelta(ms * 1000);
|
||||
return FromStaticFraction<ms, 1000>();
|
||||
}
|
||||
template <int64_t us>
|
||||
static constexpr TimeDelta Micros() {
|
||||
static_assert(us > timedelta_impl::kMinusInfinityVal, "");
|
||||
static_assert(us < timedelta_impl::kPlusInfinityVal, "");
|
||||
return TimeDelta(us);
|
||||
return FromStaticValue<us>();
|
||||
}
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
|
||||
template <typename T>
|
||||
static TimeDelta seconds(T seconds) {
|
||||
RTC_DCHECK_GT(seconds, timedelta_impl::kMinusInfinityVal / 1000000);
|
||||
RTC_DCHECK_LT(seconds, timedelta_impl::kPlusInfinityVal / 1000000);
|
||||
return TimeDelta(rtc::dchecked_cast<int64_t>(seconds) * 1000000);
|
||||
return FromFraction<1000000>(seconds);
|
||||
}
|
||||
template <
|
||||
typename T,
|
||||
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
|
||||
template <typename T>
|
||||
static TimeDelta ms(T milliseconds) {
|
||||
RTC_DCHECK_GT(milliseconds, timedelta_impl::kMinusInfinityVal / 1000);
|
||||
RTC_DCHECK_LT(milliseconds, timedelta_impl::kPlusInfinityVal / 1000);
|
||||
return TimeDelta(rtc::dchecked_cast<int64_t>(milliseconds) * 1000);
|
||||
return FromFraction<1000>(milliseconds);
|
||||
}
|
||||
template <
|
||||
typename T,
|
||||
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
|
||||
template <typename T>
|
||||
static TimeDelta us(T microseconds) {
|
||||
RTC_DCHECK_GT(microseconds, timedelta_impl::kMinusInfinityVal);
|
||||
RTC_DCHECK_LT(microseconds, timedelta_impl::kPlusInfinityVal);
|
||||
return TimeDelta(rtc::dchecked_cast<int64_t>(microseconds));
|
||||
}
|
||||
|
||||
template <typename T,
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type* =
|
||||
nullptr>
|
||||
static TimeDelta seconds(T seconds) {
|
||||
return TimeDelta::us(seconds * 1e6);
|
||||
}
|
||||
template <typename T,
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type* =
|
||||
nullptr>
|
||||
static TimeDelta ms(T milliseconds) {
|
||||
return TimeDelta::us(milliseconds * 1e3);
|
||||
}
|
||||
template <typename T,
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type* =
|
||||
nullptr>
|
||||
static TimeDelta us(T microseconds) {
|
||||
if (microseconds == std::numeric_limits<T>::infinity()) {
|
||||
return PlusInfinity();
|
||||
} else if (microseconds == -std::numeric_limits<T>::infinity()) {
|
||||
return MinusInfinity();
|
||||
} else {
|
||||
RTC_DCHECK(!std::isnan(microseconds));
|
||||
RTC_DCHECK_GT(microseconds, timedelta_impl::kMinusInfinityVal);
|
||||
RTC_DCHECK_LT(microseconds, timedelta_impl::kPlusInfinityVal);
|
||||
return TimeDelta(rtc::dchecked_cast<int64_t>(microseconds));
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type seconds() const {
|
||||
RTC_DCHECK(IsFinite());
|
||||
return rtc::dchecked_cast<T>(UnsafeSeconds());
|
||||
return FromValue(microseconds);
|
||||
}
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type ms() const {
|
||||
RTC_DCHECK(IsFinite());
|
||||
return rtc::dchecked_cast<T>(UnsafeMillis());
|
||||
T seconds() const {
|
||||
return ToFraction<1000000, T>();
|
||||
}
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type us() const {
|
||||
RTC_DCHECK(IsFinite());
|
||||
return rtc::dchecked_cast<T>(microseconds_);
|
||||
T ms() const {
|
||||
return ToFraction<1000, T>();
|
||||
}
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type ns() const {
|
||||
RTC_DCHECK_GE(us(), std::numeric_limits<T>::min() / 1000);
|
||||
RTC_DCHECK_LE(us(), std::numeric_limits<T>::max() / 1000);
|
||||
return rtc::dchecked_cast<T>(us() * 1000);
|
||||
T us() const {
|
||||
return ToValue<T>();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
|
||||
seconds() const {
|
||||
return us<T>() * 1e-6;
|
||||
}
|
||||
template <typename T>
|
||||
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
|
||||
ms() const {
|
||||
return us<T>() * 1e-3;
|
||||
}
|
||||
template <typename T>
|
||||
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
|
||||
us() const {
|
||||
return IsPlusInfinity()
|
||||
? std::numeric_limits<T>::infinity()
|
||||
: IsMinusInfinity() ? -std::numeric_limits<T>::infinity()
|
||||
: microseconds_;
|
||||
}
|
||||
template <typename T>
|
||||
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
|
||||
ns() const {
|
||||
return us<T>() * 1e3;
|
||||
template <typename T = int64_t>
|
||||
T ns() const {
|
||||
return ToMultiple<1000, T>();
|
||||
}
|
||||
|
||||
constexpr int64_t seconds_or(int64_t fallback_value) const {
|
||||
return IsFinite() ? UnsafeSeconds() : fallback_value;
|
||||
return ToFractionOr<1000000>(fallback_value);
|
||||
}
|
||||
constexpr int64_t ms_or(int64_t fallback_value) const {
|
||||
return IsFinite() ? UnsafeMillis() : fallback_value;
|
||||
return ToFractionOr<1000>(fallback_value);
|
||||
}
|
||||
constexpr int64_t us_or(int64_t fallback_value) const {
|
||||
return IsFinite() ? microseconds_ : fallback_value;
|
||||
return ToValueOr(fallback_value);
|
||||
}
|
||||
|
||||
TimeDelta Abs() const { return TimeDelta::us(std::abs(us())); }
|
||||
constexpr bool IsZero() const { return microseconds_ == 0; }
|
||||
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;
|
||||
}
|
||||
TimeDelta Clamped(TimeDelta min_delta, TimeDelta max_delta) const {
|
||||
return std::max(min_delta, std::min(*this, max_delta));
|
||||
}
|
||||
void Clamp(TimeDelta min_delta, TimeDelta max_delta) {
|
||||
*this = Clamped(min_delta, max_delta);
|
||||
}
|
||||
TimeDelta 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 TimeDelta::us(us() + other.us());
|
||||
}
|
||||
TimeDelta 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 TimeDelta::us(us() - other.us());
|
||||
}
|
||||
TimeDelta& operator-=(const TimeDelta& other) {
|
||||
*this = *this - other;
|
||||
return *this;
|
||||
}
|
||||
TimeDelta& operator+=(const TimeDelta& other) {
|
||||
*this = *this + other;
|
||||
return *this;
|
||||
}
|
||||
constexpr double operator/(const TimeDelta& other) const {
|
||||
return us<double>() / other.us<double>();
|
||||
}
|
||||
constexpr bool operator==(const TimeDelta& other) const {
|
||||
return microseconds_ == other.microseconds_;
|
||||
}
|
||||
constexpr bool operator!=(const TimeDelta& other) const {
|
||||
return microseconds_ != other.microseconds_;
|
||||
}
|
||||
constexpr bool operator<=(const TimeDelta& other) const {
|
||||
return microseconds_ <= other.microseconds_;
|
||||
}
|
||||
constexpr bool operator>=(const TimeDelta& other) const {
|
||||
return microseconds_ >= other.microseconds_;
|
||||
}
|
||||
constexpr bool operator>(const TimeDelta& other) const {
|
||||
return microseconds_ > other.microseconds_;
|
||||
}
|
||||
constexpr bool operator<(const TimeDelta& other) const {
|
||||
return microseconds_ < other.microseconds_;
|
||||
}
|
||||
|
||||
private:
|
||||
explicit constexpr TimeDelta(int64_t us) : microseconds_(us) {}
|
||||
constexpr int64_t UnsafeSeconds() const {
|
||||
return (microseconds_ + (microseconds_ >= 0 ? 500000 : -500000)) / 1000000;
|
||||
}
|
||||
constexpr int64_t UnsafeMillis() const {
|
||||
return (microseconds_ + (microseconds_ >= 0 ? 500 : -500)) / 1000;
|
||||
}
|
||||
int64_t microseconds_;
|
||||
friend class rtc_units_impl::UnitBase<TimeDelta>;
|
||||
using RelativeUnit::RelativeUnit;
|
||||
static constexpr bool one_sided = false;
|
||||
};
|
||||
|
||||
inline TimeDelta operator*(const TimeDelta& delta, const double& scalar) {
|
||||
return TimeDelta::us(std::round(delta.us() * scalar));
|
||||
}
|
||||
inline TimeDelta operator*(const double& scalar, const TimeDelta& delta) {
|
||||
return delta * scalar;
|
||||
}
|
||||
inline TimeDelta operator*(const TimeDelta& delta, const int64_t& scalar) {
|
||||
return TimeDelta::us(delta.us() * scalar);
|
||||
}
|
||||
inline TimeDelta operator*(const int64_t& scalar, const TimeDelta& delta) {
|
||||
return delta * scalar;
|
||||
}
|
||||
inline TimeDelta operator*(const TimeDelta& delta, const int32_t& scalar) {
|
||||
return TimeDelta::us(delta.us() * scalar);
|
||||
}
|
||||
inline TimeDelta operator*(const int32_t& scalar, const TimeDelta& delta) {
|
||||
return delta * scalar;
|
||||
}
|
||||
|
||||
inline TimeDelta operator/(const TimeDelta& delta, const int64_t& scalar) {
|
||||
return TimeDelta::us(delta.us() / scalar);
|
||||
}
|
||||
std::string ToString(const TimeDelta& value);
|
||||
std::string ToString(TimeDelta value);
|
||||
|
||||
#ifdef UNIT_TEST
|
||||
inline std::ostream& operator<<( // no-presubmit-check TODO(webrtc:8982)
|
||||
|
||||
@ -10,6 +10,8 @@
|
||||
|
||||
#include "api/units/time_delta.h"
|
||||
|
||||
#include <limits>
|
||||
|
||||
#include "test/gtest.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
@ -13,7 +13,7 @@
|
||||
#include "rtc_base/strings/string_builder.h"
|
||||
|
||||
namespace webrtc {
|
||||
std::string ToString(const Timestamp& value) {
|
||||
std::string ToString(Timestamp value) {
|
||||
char buf[64];
|
||||
rtc::SimpleStringBuilder sb(buf);
|
||||
if (value.IsInfinite()) {
|
||||
|
||||
@ -15,191 +15,94 @@
|
||||
#include <ostream> // no-presubmit-check TODO(webrtc:8982)
|
||||
#endif // UNIT_TEST
|
||||
|
||||
#include <math.h>
|
||||
#include <stdint.h>
|
||||
#include <limits>
|
||||
#include <string>
|
||||
#include <type_traits>
|
||||
|
||||
#include "api/units/time_delta.h"
|
||||
#include "rtc_base/checks.h"
|
||||
#include "rtc_base/numerics/safe_conversions.h"
|
||||
|
||||
namespace webrtc {
|
||||
namespace timestamp_impl {
|
||||
constexpr int64_t kPlusInfinityVal = std::numeric_limits<int64_t>::max();
|
||||
constexpr int64_t kMinusInfinityVal = std::numeric_limits<int64_t>::min();
|
||||
} // namespace timestamp_impl
|
||||
|
||||
// Timestamp represents the time that has passed since some unspecified epoch.
|
||||
// The epoch is assumed to be before any represented timestamps, this means that
|
||||
// negative values are not valid. The most notable feature is that the
|
||||
// difference of two Timestamps results in a TimeDelta.
|
||||
class Timestamp {
|
||||
class Timestamp final : public rtc_units_impl::UnitBase<Timestamp> {
|
||||
public:
|
||||
Timestamp() = delete;
|
||||
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, "");
|
||||
static_assert(seconds < timestamp_impl::kPlusInfinityVal / 1000000, "");
|
||||
return Timestamp(seconds * 1000000);
|
||||
return FromStaticFraction<seconds, 1000000>();
|
||||
}
|
||||
template <int64_t ms>
|
||||
static constexpr Timestamp Millis() {
|
||||
static_assert(ms >= 0, "");
|
||||
static_assert(ms < timestamp_impl::kPlusInfinityVal / 1000, "");
|
||||
return Timestamp(ms * 1000);
|
||||
return FromStaticFraction<ms, 1000>();
|
||||
}
|
||||
template <int64_t us>
|
||||
static constexpr Timestamp Micros() {
|
||||
static_assert(us >= 0, "");
|
||||
static_assert(us < timestamp_impl::kPlusInfinityVal, "");
|
||||
return Timestamp(us);
|
||||
return FromStaticValue<us>();
|
||||
}
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
|
||||
template <typename T>
|
||||
static Timestamp seconds(T seconds) {
|
||||
RTC_DCHECK_GE(seconds, 0);
|
||||
RTC_DCHECK_LT(seconds, timestamp_impl::kPlusInfinityVal / 1000000);
|
||||
return Timestamp(rtc::dchecked_cast<int64_t>(seconds) * 1000000);
|
||||
return FromFraction<1000000>(seconds);
|
||||
}
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
|
||||
template <typename T>
|
||||
static Timestamp ms(T milliseconds) {
|
||||
RTC_DCHECK_GE(milliseconds, 0);
|
||||
RTC_DCHECK_LT(milliseconds, timestamp_impl::kPlusInfinityVal / 1000);
|
||||
return Timestamp(rtc::dchecked_cast<int64_t>(milliseconds) * 1000);
|
||||
return FromFraction<1000>(milliseconds);
|
||||
}
|
||||
|
||||
template <
|
||||
typename T,
|
||||
typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
|
||||
template <typename T>
|
||||
static Timestamp us(T microseconds) {
|
||||
RTC_DCHECK_GE(microseconds, 0);
|
||||
RTC_DCHECK_LT(microseconds, timestamp_impl::kPlusInfinityVal);
|
||||
return Timestamp(rtc::dchecked_cast<int64_t>(microseconds));
|
||||
}
|
||||
|
||||
template <typename T,
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type* =
|
||||
nullptr>
|
||||
static Timestamp seconds(T seconds) {
|
||||
return Timestamp::us(seconds * 1e6);
|
||||
}
|
||||
|
||||
template <typename T,
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type* =
|
||||
nullptr>
|
||||
static Timestamp ms(T milliseconds) {
|
||||
return Timestamp::us(milliseconds * 1e3);
|
||||
}
|
||||
template <typename T,
|
||||
typename std::enable_if<std::is_floating_point<T>::value>::type* =
|
||||
nullptr>
|
||||
static Timestamp us(T microseconds) {
|
||||
if (microseconds == std::numeric_limits<double>::infinity()) {
|
||||
return PlusInfinity();
|
||||
} else if (microseconds == -std::numeric_limits<double>::infinity()) {
|
||||
return MinusInfinity();
|
||||
} else {
|
||||
RTC_DCHECK(!std::isnan(microseconds));
|
||||
RTC_DCHECK_GE(microseconds, 0);
|
||||
RTC_DCHECK_LT(microseconds, timestamp_impl::kPlusInfinityVal);
|
||||
return Timestamp(rtc::dchecked_cast<int64_t>(microseconds));
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type seconds() const {
|
||||
RTC_DCHECK(IsFinite());
|
||||
return rtc::dchecked_cast<T>(UnsafeSeconds());
|
||||
return FromValue(microseconds);
|
||||
}
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type ms() const {
|
||||
RTC_DCHECK(IsFinite());
|
||||
return rtc::dchecked_cast<T>(UnsafeMillis());
|
||||
T seconds() const {
|
||||
return ToFraction<1000000, T>();
|
||||
}
|
||||
template <typename T = int64_t>
|
||||
typename std::enable_if<std::is_integral<T>::value, T>::type us() const {
|
||||
RTC_DCHECK(IsFinite());
|
||||
return rtc::dchecked_cast<T>(microseconds_);
|
||||
T ms() const {
|
||||
return ToFraction<1000, T>();
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
|
||||
seconds() const {
|
||||
return us<T>() * 1e-6;
|
||||
}
|
||||
template <typename T>
|
||||
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
|
||||
ms() const {
|
||||
return us<T>() * 1e-3;
|
||||
}
|
||||
template <typename T>
|
||||
constexpr typename std::enable_if<std::is_floating_point<T>::value, T>::type
|
||||
us() const {
|
||||
return IsPlusInfinity()
|
||||
? std::numeric_limits<T>::infinity()
|
||||
: IsMinusInfinity() ? -std::numeric_limits<T>::infinity()
|
||||
: microseconds_;
|
||||
template <typename T = int64_t>
|
||||
T us() const {
|
||||
return ToValue<T>();
|
||||
}
|
||||
|
||||
constexpr int64_t seconds_or(int64_t fallback_value) const {
|
||||
return IsFinite() ? UnsafeSeconds() : fallback_value;
|
||||
return ToFractionOr<1000000>(fallback_value);
|
||||
}
|
||||
constexpr int64_t ms_or(int64_t fallback_value) const {
|
||||
return IsFinite() ? UnsafeMillis() : fallback_value;
|
||||
return ToFractionOr<1000>(fallback_value);
|
||||
}
|
||||
constexpr int64_t us_or(int64_t fallback_value) const {
|
||||
return IsFinite() ? microseconds_ : fallback_value;
|
||||
return ToValueOr(fallback_value);
|
||||
}
|
||||
|
||||
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()) {
|
||||
Timestamp operator+(const TimeDelta delta) const {
|
||||
if (IsPlusInfinity() || delta.IsPlusInfinity()) {
|
||||
RTC_DCHECK(!IsMinusInfinity());
|
||||
RTC_DCHECK(!other.IsMinusInfinity());
|
||||
RTC_DCHECK(!delta.IsMinusInfinity());
|
||||
return PlusInfinity();
|
||||
} else if (IsMinusInfinity() || other.IsMinusInfinity()) {
|
||||
} else if (IsMinusInfinity() || delta.IsMinusInfinity()) {
|
||||
RTC_DCHECK(!IsPlusInfinity());
|
||||
RTC_DCHECK(!other.IsPlusInfinity());
|
||||
RTC_DCHECK(!delta.IsPlusInfinity());
|
||||
return MinusInfinity();
|
||||
}
|
||||
return Timestamp::us(us() + other.us());
|
||||
return Timestamp::us(us() + delta.us());
|
||||
}
|
||||
Timestamp operator-(const TimeDelta& other) const {
|
||||
if (IsPlusInfinity() || other.IsMinusInfinity()) {
|
||||
Timestamp operator-(const TimeDelta delta) const {
|
||||
if (IsPlusInfinity() || delta.IsMinusInfinity()) {
|
||||
RTC_DCHECK(!IsMinusInfinity());
|
||||
RTC_DCHECK(!other.IsPlusInfinity());
|
||||
RTC_DCHECK(!delta.IsPlusInfinity());
|
||||
return PlusInfinity();
|
||||
} else if (IsMinusInfinity() || other.IsPlusInfinity()) {
|
||||
} else if (IsMinusInfinity() || delta.IsPlusInfinity()) {
|
||||
RTC_DCHECK(!IsPlusInfinity());
|
||||
RTC_DCHECK(!other.IsMinusInfinity());
|
||||
RTC_DCHECK(!delta.IsMinusInfinity());
|
||||
return MinusInfinity();
|
||||
}
|
||||
return Timestamp::us(us() - other.us());
|
||||
return Timestamp::us(us() - delta.us());
|
||||
}
|
||||
TimeDelta operator-(const Timestamp& other) const {
|
||||
TimeDelta operator-(const Timestamp other) const {
|
||||
if (IsPlusInfinity() || other.IsMinusInfinity()) {
|
||||
RTC_DCHECK(!IsMinusInfinity());
|
||||
RTC_DCHECK(!other.IsPlusInfinity());
|
||||
@ -211,45 +114,22 @@ class Timestamp {
|
||||
}
|
||||
return TimeDelta::us(us() - other.us());
|
||||
}
|
||||
Timestamp& operator-=(const TimeDelta& other) {
|
||||
*this = *this - other;
|
||||
Timestamp& operator-=(const TimeDelta delta) {
|
||||
*this = *this - delta;
|
||||
return *this;
|
||||
}
|
||||
Timestamp& operator+=(const TimeDelta& other) {
|
||||
*this = *this + other;
|
||||
Timestamp& operator+=(const TimeDelta delta) {
|
||||
*this = *this + delta;
|
||||
return *this;
|
||||
}
|
||||
constexpr bool operator==(const Timestamp& other) const {
|
||||
return microseconds_ == other.microseconds_;
|
||||
}
|
||||
constexpr bool operator!=(const Timestamp& other) const {
|
||||
return microseconds_ != other.microseconds_;
|
||||
}
|
||||
constexpr bool operator<=(const Timestamp& other) const {
|
||||
return microseconds_ <= other.microseconds_;
|
||||
}
|
||||
constexpr bool operator>=(const Timestamp& other) const {
|
||||
return microseconds_ >= other.microseconds_;
|
||||
}
|
||||
constexpr bool operator>(const Timestamp& other) const {
|
||||
return microseconds_ > other.microseconds_;
|
||||
}
|
||||
constexpr bool operator<(const Timestamp& other) const {
|
||||
return microseconds_ < other.microseconds_;
|
||||
}
|
||||
|
||||
private:
|
||||
explicit constexpr Timestamp(int64_t us) : microseconds_(us) {}
|
||||
constexpr int64_t UnsafeSeconds() const {
|
||||
return (microseconds_ + 500000) / 1000000;
|
||||
}
|
||||
constexpr int64_t UnsafeMillis() const {
|
||||
return (microseconds_ + 500) / 1000;
|
||||
}
|
||||
int64_t microseconds_;
|
||||
friend class rtc_units_impl::UnitBase<Timestamp>;
|
||||
using UnitBase::UnitBase;
|
||||
static constexpr bool one_sided = true;
|
||||
};
|
||||
|
||||
std::string ToString(const Timestamp& value);
|
||||
std::string ToString(Timestamp value);
|
||||
|
||||
#ifdef UNIT_TEST
|
||||
inline std::ostream& operator<<( // no-presubmit-check TODO(webrtc:8982)
|
||||
|
||||
Reference in New Issue
Block a user