blob: a1258e33421151ca430d53175618f16602d0e86b (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
#pragma once
#include <util/datetime/base.h>
namespace NMonotonic {
/**
* Returns current monotonic time in microseconds
*
* On Linux uses CLOCK_BOOTTIME under the hood, so it includes time passed
* during suspend and makes it safe for measuring lease times.
*/
ui64 GetMonotonicMicroSeconds();
/**
* Similar to TInstant, but measuring monotonic time
*
* On Linux uses CLOCK_BOOTTIME under the hood, so it includes time passed
* during suspend and makes it safe for measuring lease times.
*/
class TMonotonic: public TTimeBase<TMonotonic> {
using TBase = TTimeBase<TMonotonic>;
protected:
constexpr explicit TMonotonic(TValue value) noexcept
: TBase(value)
{
}
public:
constexpr TMonotonic() noexcept {
}
static constexpr TMonotonic FromValue(TValue value) noexcept {
return TMonotonic(value);
}
static inline TMonotonic Now() {
return TMonotonic::MicroSeconds(GetMonotonicMicroSeconds());
}
using TBase::Days;
using TBase::Hours;
using TBase::MicroSeconds;
using TBase::MilliSeconds;
using TBase::Minutes;
using TBase::Seconds;
static constexpr TMonotonic Max() noexcept {
return TMonotonic::FromValue(::Max<ui64>());
}
static constexpr TMonotonic Zero() noexcept {
return TMonotonic::FromValue(0);
}
static constexpr TMonotonic MicroSeconds(ui64 us) noexcept {
return TMonotonic::FromValue(TInstant::MicroSeconds(us).GetValue());
}
static constexpr TMonotonic MilliSeconds(ui64 ms) noexcept {
return TMonotonic::FromValue(TInstant::MilliSeconds(ms).GetValue());
}
static constexpr TMonotonic Seconds(ui64 s) noexcept {
return TMonotonic::FromValue(TInstant::Seconds(s).GetValue());
}
static constexpr TMonotonic Minutes(ui64 m) noexcept {
return TMonotonic::FromValue(TInstant::Minutes(m).GetValue());
}
static constexpr TMonotonic Hours(ui64 h) noexcept {
return TMonotonic::FromValue(TInstant::Hours(h).GetValue());
}
static constexpr TMonotonic Days(ui64 d) noexcept {
return TMonotonic::FromValue(TInstant::Days(d).GetValue());
}
template <class T>
inline TMonotonic& operator+=(const T& t) noexcept {
return (*this = (*this + t));
}
template <class T>
inline TMonotonic& operator-=(const T& t) noexcept {
return (*this = (*this - t));
}
};
} // namespace NMonotonic
Y_DECLARE_PODTYPE(NMonotonic::TMonotonic);
namespace std {
template <>
struct hash<NMonotonic::TMonotonic> {
size_t operator()(const NMonotonic::TMonotonic& key) const noexcept {
return hash<NMonotonic::TMonotonic::TValue>()(key.GetValue());
}
};
}
namespace NMonotonic {
constexpr TDuration operator-(const TMonotonic& l, const TMonotonic& r) {
return TInstant::FromValue(l.GetValue()) - TInstant::FromValue(r.GetValue());
}
constexpr TMonotonic operator+(const TMonotonic& l, const TDuration& r) {
TInstant result = TInstant::FromValue(l.GetValue()) + r;
return TMonotonic::FromValue(result.GetValue());
}
constexpr TMonotonic operator-(const TMonotonic& l, const TDuration& r) {
TInstant result = TInstant::FromValue(l.GetValue()) - r;
return TMonotonic::FromValue(result.GetValue());
}
} // namespace NMonotonic
// TODO: remove, alias for compatibility
using TMonotonic = NMonotonic::TMonotonic;
|
