1 // Copyright 2017 The Abseil Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 //
15 // -----------------------------------------------------------------------------
16 // File: time.h
17 // -----------------------------------------------------------------------------
18 //
19 // This header file defines abstractions for computing with absolute points
20 // in time, durations of time, and formatting and parsing time within a given
21 // time zone. The following abstractions are defined:
22 //
23 // * `absl::Time` defines an absolute, specific instance in time
24 // * `absl::Duration` defines a signed, fixed-length span of time
25 // * `absl::TimeZone` defines geopolitical time zone regions (as collected
26 // within the IANA Time Zone database (https://www.iana.org/time-zones)).
27 //
28 // Note: Absolute times are distinct from civil times, which refer to the
29 // human-scale time commonly represented by `YYYY-MM-DD hh:mm:ss`. The mapping
30 // between absolute and civil times can be specified by use of time zones
31 // (`absl::TimeZone` within this API). That is:
32 //
33 // Civil Time = F(Absolute Time, Time Zone)
34 // Absolute Time = G(Civil Time, Time Zone)
35 //
36 // See civil_time.h for abstractions related to constructing and manipulating
37 // civil time.
38 //
39 // Example:
40 //
41 // absl::TimeZone nyc;
42 // // LoadTimeZone() may fail so it's always better to check for success.
43 // if (!absl::LoadTimeZone("America/New_York", &nyc)) {
44 // // handle error case
45 // }
46 //
47 // // My flight leaves NYC on Jan 2, 2017 at 03:04:05
48 // absl::CivilSecond cs(2017, 1, 2, 3, 4, 5);
49 // absl::Time takeoff = absl::FromCivil(cs, nyc);
50 //
51 // absl::Duration flight_duration = absl::Hours(21) + absl::Minutes(35);
52 // absl::Time landing = takeoff + flight_duration;
53 //
54 // absl::TimeZone syd;
55 // if (!absl::LoadTimeZone("Australia/Sydney", &syd)) {
56 // // handle error case
57 // }
58 // std::string s = absl::FormatTime(
59 // "My flight will land in Sydney on %Y-%m-%d at %H:%M:%S",
60 // landing, syd);
61
62 #ifndef ABSL_TIME_TIME_H_
63 #define ABSL_TIME_TIME_H_
64
65 #if !defined(_MSC_VER)
66 #include <sys/time.h>
67 #else
68 // We don't include `winsock2.h` because it drags in `windows.h` and friends,
69 // and they define conflicting macros like OPAQUE, ERROR, and more. This has the
70 // potential to break Abseil users.
71 //
72 // Instead we only forward declare `timeval` and require Windows users include
73 // `winsock2.h` themselves. This is both inconsistent and troublesome, but so is
74 // including 'windows.h' so we are picking the lesser of two evils here.
75 struct timeval;
76 #endif
77 #include <chrono> // NOLINT(build/c++11)
78 #include <cmath>
79 #include <cstdint>
80 #include <ctime>
81 #include <ostream>
82 #include <string>
83 #include <type_traits>
84 #include <utility>
85
86 #include "absl/base/macros.h"
87 #include "absl/strings/string_view.h"
88 #include "absl/time/civil_time.h"
89 #include "absl/time/internal/cctz/include/cctz/time_zone.h"
90
91 namespace absl {
92 ABSL_NAMESPACE_BEGIN
93
94 class Duration; // Defined below
95 class Time; // Defined below
96 class TimeZone; // Defined below
97
98 namespace time_internal {
99 int64_t IDivDuration(bool satq, Duration num, Duration den, Duration* rem);
100 constexpr Time FromUnixDuration(Duration d);
101 constexpr Duration ToUnixDuration(Time t);
102 constexpr int64_t GetRepHi(Duration d);
103 constexpr uint32_t GetRepLo(Duration d);
104 constexpr Duration MakeDuration(int64_t hi, uint32_t lo);
105 constexpr Duration MakeDuration(int64_t hi, int64_t lo);
106 inline Duration MakePosDoubleDuration(double n);
107 constexpr int64_t kTicksPerNanosecond = 4;
108 constexpr int64_t kTicksPerSecond = 1000 * 1000 * 1000 * kTicksPerNanosecond;
109 template <std::intmax_t N>
110 constexpr Duration FromInt64(int64_t v, std::ratio<1, N>);
111 constexpr Duration FromInt64(int64_t v, std::ratio<60>);
112 constexpr Duration FromInt64(int64_t v, std::ratio<3600>);
113 template <typename T>
114 using EnableIfIntegral = typename std::enable_if<
115 std::is_integral<T>::value || std::is_enum<T>::value, int>::type;
116 template <typename T>
117 using EnableIfFloat =
118 typename std::enable_if<std::is_floating_point<T>::value, int>::type;
119 } // namespace time_internal
120
121 // Duration
122 //
123 // The `absl::Duration` class represents a signed, fixed-length span of time.
124 // A `Duration` is generated using a unit-specific factory function, or is
125 // the result of subtracting one `absl::Time` from another. Durations behave
126 // like unit-safe integers and they support all the natural integer-like
127 // arithmetic operations. Arithmetic overflows and saturates at +/- infinity.
128 // `Duration` should be passed by value rather than const reference.
129 //
130 // Factory functions `Nanoseconds()`, `Microseconds()`, `Milliseconds()`,
131 // `Seconds()`, `Minutes()`, `Hours()` and `InfiniteDuration()` allow for
132 // creation of constexpr `Duration` values
133 //
134 // Examples:
135 //
136 // constexpr absl::Duration ten_ns = absl::Nanoseconds(10);
137 // constexpr absl::Duration min = absl::Minutes(1);
138 // constexpr absl::Duration hour = absl::Hours(1);
139 // absl::Duration dur = 60 * min; // dur == hour
140 // absl::Duration half_sec = absl::Milliseconds(500);
141 // absl::Duration quarter_sec = 0.25 * absl::Seconds(1);
142 //
143 // `Duration` values can be easily converted to an integral number of units
144 // using the division operator.
145 //
146 // Example:
147 //
148 // constexpr absl::Duration dur = absl::Milliseconds(1500);
149 // int64_t ns = dur / absl::Nanoseconds(1); // ns == 1500000000
150 // int64_t ms = dur / absl::Milliseconds(1); // ms == 1500
151 // int64_t sec = dur / absl::Seconds(1); // sec == 1 (subseconds truncated)
152 // int64_t min = dur / absl::Minutes(1); // min == 0
153 //
154 // See the `IDivDuration()` and `FDivDuration()` functions below for details on
155 // how to access the fractional parts of the quotient.
156 //
157 // Alternatively, conversions can be performed using helpers such as
158 // `ToInt64Microseconds()` and `ToDoubleSeconds()`.
159 class Duration {
160 public:
161 // Value semantics.
Duration()162 constexpr Duration() : rep_hi_(0), rep_lo_(0) {} // zero-length duration
163
164 // Copyable.
165 #if !defined(__clang__) && defined(_MSC_VER) && _MSC_VER < 1910
166 // Explicitly defining the constexpr copy constructor avoids an MSVC bug.
Duration(const Duration & d)167 constexpr Duration(const Duration& d)
168 : rep_hi_(d.rep_hi_), rep_lo_(d.rep_lo_) {}
169 #else
170 constexpr Duration(const Duration& d) = default;
171 #endif
172 Duration& operator=(const Duration& d) = default;
173
174 // Compound assignment operators.
175 Duration& operator+=(Duration d);
176 Duration& operator-=(Duration d);
177 Duration& operator*=(int64_t r);
178 Duration& operator*=(double r);
179 Duration& operator/=(int64_t r);
180 Duration& operator/=(double r);
181 Duration& operator%=(Duration rhs);
182
183 // Overloads that forward to either the int64_t or double overloads above.
184 // Integer operands must be representable as int64_t.
185 template <typename T, time_internal::EnableIfIntegral<T> = 0>
186 Duration& operator*=(T r) {
187 int64_t x = r;
188 return *this *= x;
189 }
190
191 template <typename T, time_internal::EnableIfIntegral<T> = 0>
192 Duration& operator/=(T r) {
193 int64_t x = r;
194 return *this /= x;
195 }
196
197 template <typename T, time_internal::EnableIfFloat<T> = 0>
198 Duration& operator*=(T r) {
199 double x = r;
200 return *this *= x;
201 }
202
203 template <typename T, time_internal::EnableIfFloat<T> = 0>
204 Duration& operator/=(T r) {
205 double x = r;
206 return *this /= x;
207 }
208
209 template <typename H>
AbslHashValue(H h,Duration d)210 friend H AbslHashValue(H h, Duration d) {
211 return H::combine(std::move(h), d.rep_hi_, d.rep_lo_);
212 }
213
214 private:
215 friend constexpr int64_t time_internal::GetRepHi(Duration d);
216 friend constexpr uint32_t time_internal::GetRepLo(Duration d);
217 friend constexpr Duration time_internal::MakeDuration(int64_t hi,
218 uint32_t lo);
Duration(int64_t hi,uint32_t lo)219 constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
220 int64_t rep_hi_;
221 uint32_t rep_lo_;
222 };
223
224 // Relational Operators
225 constexpr bool operator<(Duration lhs, Duration rhs);
226 constexpr bool operator>(Duration lhs, Duration rhs) { return rhs < lhs; }
227 constexpr bool operator>=(Duration lhs, Duration rhs) { return !(lhs < rhs); }
228 constexpr bool operator<=(Duration lhs, Duration rhs) { return !(rhs < lhs); }
229 constexpr bool operator==(Duration lhs, Duration rhs);
230 constexpr bool operator!=(Duration lhs, Duration rhs) { return !(lhs == rhs); }
231
232 // Additive Operators
233 constexpr Duration operator-(Duration d);
234 inline Duration operator+(Duration lhs, Duration rhs) { return lhs += rhs; }
235 inline Duration operator-(Duration lhs, Duration rhs) { return lhs -= rhs; }
236
237 // Multiplicative Operators
238 // Integer operands must be representable as int64_t.
239 template <typename T>
240 Duration operator*(Duration lhs, T rhs) {
241 return lhs *= rhs;
242 }
243 template <typename T>
244 Duration operator*(T lhs, Duration rhs) {
245 return rhs *= lhs;
246 }
247 template <typename T>
248 Duration operator/(Duration lhs, T rhs) {
249 return lhs /= rhs;
250 }
251 inline int64_t operator/(Duration lhs, Duration rhs) {
252 return time_internal::IDivDuration(true, lhs, rhs,
253 &lhs); // trunc towards zero
254 }
255 inline Duration operator%(Duration lhs, Duration rhs) { return lhs %= rhs; }
256
257 // IDivDuration()
258 //
259 // Divides a numerator `Duration` by a denominator `Duration`, returning the
260 // quotient and remainder. The remainder always has the same sign as the
261 // numerator. The returned quotient and remainder respect the identity:
262 //
263 // numerator = denominator * quotient + remainder
264 //
265 // Returned quotients are capped to the range of `int64_t`, with the difference
266 // spilling into the remainder to uphold the above identity. This means that the
267 // remainder returned could differ from the remainder returned by
268 // `Duration::operator%` for huge quotients.
269 //
270 // See also the notes on `InfiniteDuration()` below regarding the behavior of
271 // division involving zero and infinite durations.
272 //
273 // Example:
274 //
275 // constexpr absl::Duration a =
276 // absl::Seconds(std::numeric_limits<int64_t>::max()); // big
277 // constexpr absl::Duration b = absl::Nanoseconds(1); // small
278 //
279 // absl::Duration rem = a % b;
280 // // rem == absl::ZeroDuration()
281 //
282 // // Here, q would overflow int64_t, so rem accounts for the difference.
283 // int64_t q = absl::IDivDuration(a, b, &rem);
284 // // q == std::numeric_limits<int64_t>::max(), rem == a - b * q
IDivDuration(Duration num,Duration den,Duration * rem)285 inline int64_t IDivDuration(Duration num, Duration den, Duration* rem) {
286 return time_internal::IDivDuration(true, num, den,
287 rem); // trunc towards zero
288 }
289
290 // FDivDuration()
291 //
292 // Divides a `Duration` numerator into a fractional number of units of a
293 // `Duration` denominator.
294 //
295 // See also the notes on `InfiniteDuration()` below regarding the behavior of
296 // division involving zero and infinite durations.
297 //
298 // Example:
299 //
300 // double d = absl::FDivDuration(absl::Milliseconds(1500), absl::Seconds(1));
301 // // d == 1.5
302 double FDivDuration(Duration num, Duration den);
303
304 // ZeroDuration()
305 //
306 // Returns a zero-length duration. This function behaves just like the default
307 // constructor, but the name helps make the semantics clear at call sites.
ZeroDuration()308 constexpr Duration ZeroDuration() { return Duration(); }
309
310 // AbsDuration()
311 //
312 // Returns the absolute value of a duration.
AbsDuration(Duration d)313 inline Duration AbsDuration(Duration d) {
314 return (d < ZeroDuration()) ? -d : d;
315 }
316
317 // Trunc()
318 //
319 // Truncates a duration (toward zero) to a multiple of a non-zero unit.
320 //
321 // Example:
322 //
323 // absl::Duration d = absl::Nanoseconds(123456789);
324 // absl::Duration a = absl::Trunc(d, absl::Microseconds(1)); // 123456us
325 Duration Trunc(Duration d, Duration unit);
326
327 // Floor()
328 //
329 // Floors a duration using the passed duration unit to its largest value not
330 // greater than the duration.
331 //
332 // Example:
333 //
334 // absl::Duration d = absl::Nanoseconds(123456789);
335 // absl::Duration b = absl::Floor(d, absl::Microseconds(1)); // 123456us
336 Duration Floor(Duration d, Duration unit);
337
338 // Ceil()
339 //
340 // Returns the ceiling of a duration using the passed duration unit to its
341 // smallest value not less than the duration.
342 //
343 // Example:
344 //
345 // absl::Duration d = absl::Nanoseconds(123456789);
346 // absl::Duration c = absl::Ceil(d, absl::Microseconds(1)); // 123457us
347 Duration Ceil(Duration d, Duration unit);
348
349 // InfiniteDuration()
350 //
351 // Returns an infinite `Duration`. To get a `Duration` representing negative
352 // infinity, use `-InfiniteDuration()`.
353 //
354 // Duration arithmetic overflows to +/- infinity and saturates. In general,
355 // arithmetic with `Duration` infinities is similar to IEEE 754 infinities
356 // except where IEEE 754 NaN would be involved, in which case +/-
357 // `InfiniteDuration()` is used in place of a "nan" Duration.
358 //
359 // Examples:
360 //
361 // constexpr absl::Duration inf = absl::InfiniteDuration();
362 // const absl::Duration d = ... any finite duration ...
363 //
364 // inf == inf + inf
365 // inf == inf + d
366 // inf == inf - inf
367 // -inf == d - inf
368 //
369 // inf == d * 1e100
370 // inf == inf / 2
371 // 0 == d / inf
372 // INT64_MAX == inf / d
373 //
374 // d < inf
375 // -inf < d
376 //
377 // // Division by zero returns infinity, or INT64_MIN/MAX where appropriate.
378 // inf == d / 0
379 // INT64_MAX == d / absl::ZeroDuration()
380 //
381 // The examples involving the `/` operator above also apply to `IDivDuration()`
382 // and `FDivDuration()`.
383 constexpr Duration InfiniteDuration();
384
385 // Nanoseconds()
386 // Microseconds()
387 // Milliseconds()
388 // Seconds()
389 // Minutes()
390 // Hours()
391 //
392 // Factory functions for constructing `Duration` values from an integral number
393 // of the unit indicated by the factory function's name. The number must be
394 // representable as int64_t.
395 //
396 // NOTE: no "Days()" factory function exists because "a day" is ambiguous.
397 // Civil days are not always 24 hours long, and a 24-hour duration often does
398 // not correspond with a civil day. If a 24-hour duration is needed, use
399 // `absl::Hours(24)`. If you actually want a civil day, use absl::CivilDay
400 // from civil_time.h.
401 //
402 // Example:
403 //
404 // absl::Duration a = absl::Seconds(60);
405 // absl::Duration b = absl::Minutes(1); // b == a
406 template <typename T, time_internal::EnableIfIntegral<T> = 0>
Nanoseconds(T n)407 constexpr Duration Nanoseconds(T n) {
408 return time_internal::FromInt64(n, std::nano{});
409 }
410 template <typename T, time_internal::EnableIfIntegral<T> = 0>
Microseconds(T n)411 constexpr Duration Microseconds(T n) {
412 return time_internal::FromInt64(n, std::micro{});
413 }
414 template <typename T, time_internal::EnableIfIntegral<T> = 0>
Milliseconds(T n)415 constexpr Duration Milliseconds(T n) {
416 return time_internal::FromInt64(n, std::milli{});
417 }
418 template <typename T, time_internal::EnableIfIntegral<T> = 0>
Seconds(T n)419 constexpr Duration Seconds(T n) {
420 return time_internal::FromInt64(n, std::ratio<1>{});
421 }
422 template <typename T, time_internal::EnableIfIntegral<T> = 0>
Minutes(T n)423 constexpr Duration Minutes(T n) {
424 return time_internal::FromInt64(n, std::ratio<60>{});
425 }
426 template <typename T, time_internal::EnableIfIntegral<T> = 0>
Hours(T n)427 constexpr Duration Hours(T n) {
428 return time_internal::FromInt64(n, std::ratio<3600>{});
429 }
430
431 // Factory overloads for constructing `Duration` values from a floating-point
432 // number of the unit indicated by the factory function's name. These functions
433 // exist for convenience, but they are not as efficient as the integral
434 // factories, which should be preferred.
435 //
436 // Example:
437 //
438 // auto a = absl::Seconds(1.5); // OK
439 // auto b = absl::Milliseconds(1500); // BETTER
440 template <typename T, time_internal::EnableIfFloat<T> = 0>
Nanoseconds(T n)441 Duration Nanoseconds(T n) {
442 return n * Nanoseconds(1);
443 }
444 template <typename T, time_internal::EnableIfFloat<T> = 0>
Microseconds(T n)445 Duration Microseconds(T n) {
446 return n * Microseconds(1);
447 }
448 template <typename T, time_internal::EnableIfFloat<T> = 0>
Milliseconds(T n)449 Duration Milliseconds(T n) {
450 return n * Milliseconds(1);
451 }
452 template <typename T, time_internal::EnableIfFloat<T> = 0>
Seconds(T n)453 Duration Seconds(T n) {
454 if (n >= 0) { // Note: `NaN >= 0` is false.
455 if (n >= static_cast<T>((std::numeric_limits<int64_t>::max)())) {
456 return InfiniteDuration();
457 }
458 return time_internal::MakePosDoubleDuration(n);
459 } else {
460 if (std::isnan(n))
461 return std::signbit(n) ? -InfiniteDuration() : InfiniteDuration();
462 if (n <= (std::numeric_limits<int64_t>::min)()) return -InfiniteDuration();
463 return -time_internal::MakePosDoubleDuration(-n);
464 }
465 }
466 template <typename T, time_internal::EnableIfFloat<T> = 0>
Minutes(T n)467 Duration Minutes(T n) {
468 return n * Minutes(1);
469 }
470 template <typename T, time_internal::EnableIfFloat<T> = 0>
Hours(T n)471 Duration Hours(T n) {
472 return n * Hours(1);
473 }
474
475 // ToInt64Nanoseconds()
476 // ToInt64Microseconds()
477 // ToInt64Milliseconds()
478 // ToInt64Seconds()
479 // ToInt64Minutes()
480 // ToInt64Hours()
481 //
482 // Helper functions that convert a Duration to an integral count of the
483 // indicated unit. These return the same results as the `IDivDuration()`
484 // function, though they usually do so more efficiently; see the
485 // documentation of `IDivDuration()` for details about overflow, etc.
486 //
487 // Example:
488 //
489 // absl::Duration d = absl::Milliseconds(1500);
490 // int64_t isec = absl::ToInt64Seconds(d); // isec == 1
491 ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Nanoseconds(Duration d);
492 ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Microseconds(Duration d);
493 ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Milliseconds(Duration d);
494 ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Seconds(Duration d);
495 ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Minutes(Duration d);
496 ABSL_ATTRIBUTE_PURE_FUNCTION int64_t ToInt64Hours(Duration d);
497
498 // ToDoubleNanoSeconds()
499 // ToDoubleMicroseconds()
500 // ToDoubleMilliseconds()
501 // ToDoubleSeconds()
502 // ToDoubleMinutes()
503 // ToDoubleHours()
504 //
505 // Helper functions that convert a Duration to a floating point count of the
506 // indicated unit. These functions are shorthand for the `FDivDuration()`
507 // function above; see its documentation for details about overflow, etc.
508 //
509 // Example:
510 //
511 // absl::Duration d = absl::Milliseconds(1500);
512 // double dsec = absl::ToDoubleSeconds(d); // dsec == 1.5
513 ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleNanoseconds(Duration d);
514 ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMicroseconds(Duration d);
515 ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMilliseconds(Duration d);
516 ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleSeconds(Duration d);
517 ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleMinutes(Duration d);
518 ABSL_ATTRIBUTE_PURE_FUNCTION double ToDoubleHours(Duration d);
519
520 // FromChrono()
521 //
522 // Converts any of the pre-defined std::chrono durations to an absl::Duration.
523 //
524 // Example:
525 //
526 // std::chrono::milliseconds ms(123);
527 // absl::Duration d = absl::FromChrono(ms);
528 constexpr Duration FromChrono(const std::chrono::nanoseconds& d);
529 constexpr Duration FromChrono(const std::chrono::microseconds& d);
530 constexpr Duration FromChrono(const std::chrono::milliseconds& d);
531 constexpr Duration FromChrono(const std::chrono::seconds& d);
532 constexpr Duration FromChrono(const std::chrono::minutes& d);
533 constexpr Duration FromChrono(const std::chrono::hours& d);
534
535 // ToChronoNanoseconds()
536 // ToChronoMicroseconds()
537 // ToChronoMilliseconds()
538 // ToChronoSeconds()
539 // ToChronoMinutes()
540 // ToChronoHours()
541 //
542 // Converts an absl::Duration to any of the pre-defined std::chrono durations.
543 // If overflow would occur, the returned value will saturate at the min/max
544 // chrono duration value instead.
545 //
546 // Example:
547 //
548 // absl::Duration d = absl::Microseconds(123);
549 // auto x = absl::ToChronoMicroseconds(d);
550 // auto y = absl::ToChronoNanoseconds(d); // x == y
551 // auto z = absl::ToChronoSeconds(absl::InfiniteDuration());
552 // // z == std::chrono::seconds::max()
553 std::chrono::nanoseconds ToChronoNanoseconds(Duration d);
554 std::chrono::microseconds ToChronoMicroseconds(Duration d);
555 std::chrono::milliseconds ToChronoMilliseconds(Duration d);
556 std::chrono::seconds ToChronoSeconds(Duration d);
557 std::chrono::minutes ToChronoMinutes(Duration d);
558 std::chrono::hours ToChronoHours(Duration d);
559
560 // FormatDuration()
561 //
562 // Returns a string representing the duration in the form "72h3m0.5s".
563 // Returns "inf" or "-inf" for +/- `InfiniteDuration()`.
564 std::string FormatDuration(Duration d);
565
566 // Output stream operator.
567 inline std::ostream& operator<<(std::ostream& os, Duration d) {
568 return os << FormatDuration(d);
569 }
570
571 // ParseDuration()
572 //
573 // Parses a duration string consisting of a possibly signed sequence of
574 // decimal numbers, each with an optional fractional part and a unit
575 // suffix. The valid suffixes are "ns", "us" "ms", "s", "m", and "h".
576 // Simple examples include "300ms", "-1.5h", and "2h45m". Parses "0" as
577 // `ZeroDuration()`. Parses "inf" and "-inf" as +/- `InfiniteDuration()`.
578 bool ParseDuration(absl::string_view dur_string, Duration* d);
579
580 // AbslParseFlag()
581 //
582 // Parses a command-line flag string representation `text` into a a Duration
583 // value. Duration flags must be specified in a format that is valid input for
584 // `absl::ParseDuration()`.
585 bool AbslParseFlag(absl::string_view text, Duration* dst, std::string* error);
586
587
588 // AbslUnparseFlag()
589 //
590 // Unparses a Duration value into a command-line string representation using
591 // the format specified by `absl::ParseDuration()`.
592 std::string AbslUnparseFlag(Duration d);
593
594 ABSL_DEPRECATED("Use AbslParseFlag() instead.")
595 bool ParseFlag(const std::string& text, Duration* dst, std::string* error);
596 ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
597 std::string UnparseFlag(Duration d);
598
599 // Time
600 //
601 // An `absl::Time` represents a specific instant in time. Arithmetic operators
602 // are provided for naturally expressing time calculations. Instances are
603 // created using `absl::Now()` and the `absl::From*()` factory functions that
604 // accept the gamut of other time representations. Formatting and parsing
605 // functions are provided for conversion to and from strings. `absl::Time`
606 // should be passed by value rather than const reference.
607 //
608 // `absl::Time` assumes there are 60 seconds in a minute, which means the
609 // underlying time scales must be "smeared" to eliminate leap seconds.
610 // See https://developers.google.com/time/smear.
611 //
612 // Even though `absl::Time` supports a wide range of timestamps, exercise
613 // caution when using values in the distant past. `absl::Time` uses the
614 // Proleptic Gregorian calendar, which extends the Gregorian calendar backward
615 // to dates before its introduction in 1582.
616 // See https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar
617 // for more information. Use the ICU calendar classes to convert a date in
618 // some other calendar (http://userguide.icu-project.org/datetime/calendar).
619 //
620 // Similarly, standardized time zones are a reasonably recent innovation, with
621 // the Greenwich prime meridian being established in 1884. The TZ database
622 // itself does not profess accurate offsets for timestamps prior to 1970. The
623 // breakdown of future timestamps is subject to the whim of regional
624 // governments.
625 //
626 // The `absl::Time` class represents an instant in time as a count of clock
627 // ticks of some granularity (resolution) from some starting point (epoch).
628 //
629 // `absl::Time` uses a resolution that is high enough to avoid loss in
630 // precision, and a range that is wide enough to avoid overflow, when
631 // converting between tick counts in most Google time scales (i.e., resolution
632 // of at least one nanosecond, and range +/-100 billion years). Conversions
633 // between the time scales are performed by truncating (towards negative
634 // infinity) to the nearest representable point.
635 //
636 // Examples:
637 //
638 // absl::Time t1 = ...;
639 // absl::Time t2 = t1 + absl::Minutes(2);
640 // absl::Duration d = t2 - t1; // == absl::Minutes(2)
641 //
642 class Time {
643 public:
644 // Value semantics.
645
646 // Returns the Unix epoch. However, those reading your code may not know
647 // or expect the Unix epoch as the default value, so make your code more
648 // readable by explicitly initializing all instances before use.
649 //
650 // Example:
651 // absl::Time t = absl::UnixEpoch();
652 // absl::Time t = absl::Now();
653 // absl::Time t = absl::TimeFromTimeval(tv);
654 // absl::Time t = absl::InfinitePast();
655 constexpr Time() = default;
656
657 // Copyable.
658 constexpr Time(const Time& t) = default;
659 Time& operator=(const Time& t) = default;
660
661 // Assignment operators.
662 Time& operator+=(Duration d) {
663 rep_ += d;
664 return *this;
665 }
666 Time& operator-=(Duration d) {
667 rep_ -= d;
668 return *this;
669 }
670
671 // Time::Breakdown
672 //
673 // The calendar and wall-clock (aka "civil time") components of an
674 // `absl::Time` in a certain `absl::TimeZone`. This struct is not
675 // intended to represent an instant in time. So, rather than passing
676 // a `Time::Breakdown` to a function, pass an `absl::Time` and an
677 // `absl::TimeZone`.
678 //
679 // Deprecated. Use `absl::TimeZone::CivilInfo`.
680 struct
681 Breakdown {
682 int64_t year; // year (e.g., 2013)
683 int month; // month of year [1:12]
684 int day; // day of month [1:31]
685 int hour; // hour of day [0:23]
686 int minute; // minute of hour [0:59]
687 int second; // second of minute [0:59]
688 Duration subsecond; // [Seconds(0):Seconds(1)) if finite
689 int weekday; // 1==Mon, ..., 7=Sun
690 int yearday; // day of year [1:366]
691
692 // Note: The following fields exist for backward compatibility
693 // with older APIs. Accessing these fields directly is a sign of
694 // imprudent logic in the calling code. Modern time-related code
695 // should only access this data indirectly by way of FormatTime().
696 // These fields are undefined for InfiniteFuture() and InfinitePast().
697 int offset; // seconds east of UTC
698 bool is_dst; // is offset non-standard?
699 const char* zone_abbr; // time-zone abbreviation (e.g., "PST")
700 };
701
702 // Time::In()
703 //
704 // Returns the breakdown of this instant in the given TimeZone.
705 //
706 // Deprecated. Use `absl::TimeZone::At(Time)`.
707 Breakdown In(TimeZone tz) const;
708
709 template <typename H>
AbslHashValue(H h,Time t)710 friend H AbslHashValue(H h, Time t) {
711 return H::combine(std::move(h), t.rep_);
712 }
713
714 private:
715 friend constexpr Time time_internal::FromUnixDuration(Duration d);
716 friend constexpr Duration time_internal::ToUnixDuration(Time t);
717 friend constexpr bool operator<(Time lhs, Time rhs);
718 friend constexpr bool operator==(Time lhs, Time rhs);
719 friend Duration operator-(Time lhs, Time rhs);
720 friend constexpr Time UniversalEpoch();
721 friend constexpr Time InfiniteFuture();
722 friend constexpr Time InfinitePast();
Time(Duration rep)723 constexpr explicit Time(Duration rep) : rep_(rep) {}
724 Duration rep_;
725 };
726
727 // Relational Operators
728 constexpr bool operator<(Time lhs, Time rhs) { return lhs.rep_ < rhs.rep_; }
729 constexpr bool operator>(Time lhs, Time rhs) { return rhs < lhs; }
730 constexpr bool operator>=(Time lhs, Time rhs) { return !(lhs < rhs); }
731 constexpr bool operator<=(Time lhs, Time rhs) { return !(rhs < lhs); }
732 constexpr bool operator==(Time lhs, Time rhs) { return lhs.rep_ == rhs.rep_; }
733 constexpr bool operator!=(Time lhs, Time rhs) { return !(lhs == rhs); }
734
735 // Additive Operators
736 inline Time operator+(Time lhs, Duration rhs) { return lhs += rhs; }
737 inline Time operator+(Duration lhs, Time rhs) { return rhs += lhs; }
738 inline Time operator-(Time lhs, Duration rhs) { return lhs -= rhs; }
739 inline Duration operator-(Time lhs, Time rhs) { return lhs.rep_ - rhs.rep_; }
740
741 // UnixEpoch()
742 //
743 // Returns the `absl::Time` representing "1970-01-01 00:00:00.0 +0000".
UnixEpoch()744 constexpr Time UnixEpoch() { return Time(); }
745
746 // UniversalEpoch()
747 //
748 // Returns the `absl::Time` representing "0001-01-01 00:00:00.0 +0000", the
749 // epoch of the ICU Universal Time Scale.
UniversalEpoch()750 constexpr Time UniversalEpoch() {
751 // 719162 is the number of days from 0001-01-01 to 1970-01-01,
752 // assuming the Gregorian calendar.
753 return Time(time_internal::MakeDuration(-24 * 719162 * int64_t{3600}, 0U));
754 }
755
756 // InfiniteFuture()
757 //
758 // Returns an `absl::Time` that is infinitely far in the future.
InfiniteFuture()759 constexpr Time InfiniteFuture() {
760 return Time(
761 time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(), ~0U));
762 }
763
764 // InfinitePast()
765 //
766 // Returns an `absl::Time` that is infinitely far in the past.
InfinitePast()767 constexpr Time InfinitePast() {
768 return Time(
769 time_internal::MakeDuration((std::numeric_limits<int64_t>::min)(), ~0U));
770 }
771
772 // FromUnixNanos()
773 // FromUnixMicros()
774 // FromUnixMillis()
775 // FromUnixSeconds()
776 // FromTimeT()
777 // FromUDate()
778 // FromUniversal()
779 //
780 // Creates an `absl::Time` from a variety of other representations.
781 constexpr Time FromUnixNanos(int64_t ns);
782 constexpr Time FromUnixMicros(int64_t us);
783 constexpr Time FromUnixMillis(int64_t ms);
784 constexpr Time FromUnixSeconds(int64_t s);
785 constexpr Time FromTimeT(time_t t);
786 Time FromUDate(double udate);
787 Time FromUniversal(int64_t universal);
788
789 // ToUnixNanos()
790 // ToUnixMicros()
791 // ToUnixMillis()
792 // ToUnixSeconds()
793 // ToTimeT()
794 // ToUDate()
795 // ToUniversal()
796 //
797 // Converts an `absl::Time` to a variety of other representations. Note that
798 // these operations round down toward negative infinity where necessary to
799 // adjust to the resolution of the result type. Beware of possible time_t
800 // over/underflow in ToTime{T,val,spec}() on 32-bit platforms.
801 int64_t ToUnixNanos(Time t);
802 int64_t ToUnixMicros(Time t);
803 int64_t ToUnixMillis(Time t);
804 int64_t ToUnixSeconds(Time t);
805 time_t ToTimeT(Time t);
806 double ToUDate(Time t);
807 int64_t ToUniversal(Time t);
808
809 // DurationFromTimespec()
810 // DurationFromTimeval()
811 // ToTimespec()
812 // ToTimeval()
813 // TimeFromTimespec()
814 // TimeFromTimeval()
815 // ToTimespec()
816 // ToTimeval()
817 //
818 // Some APIs use a timespec or a timeval as a Duration (e.g., nanosleep(2)
819 // and select(2)), while others use them as a Time (e.g. clock_gettime(2)
820 // and gettimeofday(2)), so conversion functions are provided for both cases.
821 // The "to timespec/val" direction is easily handled via overloading, but
822 // for "from timespec/val" the desired type is part of the function name.
823 Duration DurationFromTimespec(timespec ts);
824 Duration DurationFromTimeval(timeval tv);
825 timespec ToTimespec(Duration d);
826 timeval ToTimeval(Duration d);
827 Time TimeFromTimespec(timespec ts);
828 Time TimeFromTimeval(timeval tv);
829 timespec ToTimespec(Time t);
830 timeval ToTimeval(Time t);
831
832 // FromChrono()
833 //
834 // Converts a std::chrono::system_clock::time_point to an absl::Time.
835 //
836 // Example:
837 //
838 // auto tp = std::chrono::system_clock::from_time_t(123);
839 // absl::Time t = absl::FromChrono(tp);
840 // // t == absl::FromTimeT(123)
841 Time FromChrono(const std::chrono::system_clock::time_point& tp);
842
843 // ToChronoTime()
844 //
845 // Converts an absl::Time to a std::chrono::system_clock::time_point. If
846 // overflow would occur, the returned value will saturate at the min/max time
847 // point value instead.
848 //
849 // Example:
850 //
851 // absl::Time t = absl::FromTimeT(123);
852 // auto tp = absl::ToChronoTime(t);
853 // // tp == std::chrono::system_clock::from_time_t(123);
854 std::chrono::system_clock::time_point ToChronoTime(Time);
855
856 // AbslParseFlag()
857 //
858 // Parses the command-line flag string representation `text` into a Time value.
859 // Time flags must be specified in a format that matches absl::RFC3339_full.
860 //
861 // For example:
862 //
863 // --start_time=2016-01-02T03:04:05.678+08:00
864 //
865 // Note: A UTC offset (or 'Z' indicating a zero-offset from UTC) is required.
866 //
867 // Additionally, if you'd like to specify a time as a count of
868 // seconds/milliseconds/etc from the Unix epoch, use an absl::Duration flag
869 // and add that duration to absl::UnixEpoch() to get an absl::Time.
870 bool AbslParseFlag(absl::string_view text, Time* t, std::string* error);
871
872 // AbslUnparseFlag()
873 //
874 // Unparses a Time value into a command-line string representation using
875 // the format specified by `absl::ParseTime()`.
876 std::string AbslUnparseFlag(Time t);
877
878 ABSL_DEPRECATED("Use AbslParseFlag() instead.")
879 bool ParseFlag(const std::string& text, Time* t, std::string* error);
880 ABSL_DEPRECATED("Use AbslUnparseFlag() instead.")
881 std::string UnparseFlag(Time t);
882
883 // TimeZone
884 //
885 // The `absl::TimeZone` is an opaque, small, value-type class representing a
886 // geo-political region within which particular rules are used for converting
887 // between absolute and civil times (see https://git.io/v59Ly). `absl::TimeZone`
888 // values are named using the TZ identifiers from the IANA Time Zone Database,
889 // such as "America/Los_Angeles" or "Australia/Sydney". `absl::TimeZone` values
890 // are created from factory functions such as `absl::LoadTimeZone()`. Note:
891 // strings like "PST" and "EDT" are not valid TZ identifiers. Prefer to pass by
892 // value rather than const reference.
893 //
894 // For more on the fundamental concepts of time zones, absolute times, and civil
895 // times, see https://github.com/google/cctz#fundamental-concepts
896 //
897 // Examples:
898 //
899 // absl::TimeZone utc = absl::UTCTimeZone();
900 // absl::TimeZone pst = absl::FixedTimeZone(-8 * 60 * 60);
901 // absl::TimeZone loc = absl::LocalTimeZone();
902 // absl::TimeZone lax;
903 // if (!absl::LoadTimeZone("America/Los_Angeles", &lax)) {
904 // // handle error case
905 // }
906 //
907 // See also:
908 // - https://github.com/google/cctz
909 // - https://www.iana.org/time-zones
910 // - https://en.wikipedia.org/wiki/Zoneinfo
911 class TimeZone {
912 public:
TimeZone(time_internal::cctz::time_zone tz)913 explicit TimeZone(time_internal::cctz::time_zone tz) : cz_(tz) {}
914 TimeZone() = default; // UTC, but prefer UTCTimeZone() to be explicit.
915
916 // Copyable.
917 TimeZone(const TimeZone&) = default;
918 TimeZone& operator=(const TimeZone&) = default;
919
time_zone()920 explicit operator time_internal::cctz::time_zone() const { return cz_; }
921
name()922 std::string name() const { return cz_.name(); }
923
924 // TimeZone::CivilInfo
925 //
926 // Information about the civil time corresponding to an absolute time.
927 // This struct is not intended to represent an instant in time. So, rather
928 // than passing a `TimeZone::CivilInfo` to a function, pass an `absl::Time`
929 // and an `absl::TimeZone`.
930 struct CivilInfo {
931 CivilSecond cs;
932 Duration subsecond;
933
934 // Note: The following fields exist for backward compatibility
935 // with older APIs. Accessing these fields directly is a sign of
936 // imprudent logic in the calling code. Modern time-related code
937 // should only access this data indirectly by way of FormatTime().
938 // These fields are undefined for InfiniteFuture() and InfinitePast().
939 int offset; // seconds east of UTC
940 bool is_dst; // is offset non-standard?
941 const char* zone_abbr; // time-zone abbreviation (e.g., "PST")
942 };
943
944 // TimeZone::At(Time)
945 //
946 // Returns the civil time for this TimeZone at a certain `absl::Time`.
947 // If the input time is infinite, the output civil second will be set to
948 // CivilSecond::max() or min(), and the subsecond will be infinite.
949 //
950 // Example:
951 //
952 // const auto epoch = lax.At(absl::UnixEpoch());
953 // // epoch.cs == 1969-12-31 16:00:00
954 // // epoch.subsecond == absl::ZeroDuration()
955 // // epoch.offset == -28800
956 // // epoch.is_dst == false
957 // // epoch.abbr == "PST"
958 CivilInfo At(Time t) const;
959
960 // TimeZone::TimeInfo
961 //
962 // Information about the absolute times corresponding to a civil time.
963 // (Subseconds must be handled separately.)
964 //
965 // It is possible for a caller to pass a civil-time value that does
966 // not represent an actual or unique instant in time (due to a shift
967 // in UTC offset in the TimeZone, which results in a discontinuity in
968 // the civil-time components). For example, a daylight-saving-time
969 // transition skips or repeats civil times---in the United States,
970 // March 13, 2011 02:15 never occurred, while November 6, 2011 01:15
971 // occurred twice---so requests for such times are not well-defined.
972 // To account for these possibilities, `absl::TimeZone::TimeInfo` is
973 // richer than just a single `absl::Time`.
974 struct TimeInfo {
975 enum CivilKind {
976 UNIQUE, // the civil time was singular (pre == trans == post)
977 SKIPPED, // the civil time did not exist (pre >= trans > post)
978 REPEATED, // the civil time was ambiguous (pre < trans <= post)
979 } kind;
980 Time pre; // time calculated using the pre-transition offset
981 Time trans; // when the civil-time discontinuity occurred
982 Time post; // time calculated using the post-transition offset
983 };
984
985 // TimeZone::At(CivilSecond)
986 //
987 // Returns an `absl::TimeInfo` containing the absolute time(s) for this
988 // TimeZone at an `absl::CivilSecond`. When the civil time is skipped or
989 // repeated, returns times calculated using the pre-transition and post-
990 // transition UTC offsets, plus the transition time itself.
991 //
992 // Examples:
993 //
994 // // A unique civil time
995 // const auto jan01 = lax.At(absl::CivilSecond(2011, 1, 1, 0, 0, 0));
996 // // jan01.kind == TimeZone::TimeInfo::UNIQUE
997 // // jan01.pre is 2011-01-01 00:00:00 -0800
998 // // jan01.trans is 2011-01-01 00:00:00 -0800
999 // // jan01.post is 2011-01-01 00:00:00 -0800
1000 //
1001 // // A Spring DST transition, when there is a gap in civil time
1002 // const auto mar13 = lax.At(absl::CivilSecond(2011, 3, 13, 2, 15, 0));
1003 // // mar13.kind == TimeZone::TimeInfo::SKIPPED
1004 // // mar13.pre is 2011-03-13 03:15:00 -0700
1005 // // mar13.trans is 2011-03-13 03:00:00 -0700
1006 // // mar13.post is 2011-03-13 01:15:00 -0800
1007 //
1008 // // A Fall DST transition, when civil times are repeated
1009 // const auto nov06 = lax.At(absl::CivilSecond(2011, 11, 6, 1, 15, 0));
1010 // // nov06.kind == TimeZone::TimeInfo::REPEATED
1011 // // nov06.pre is 2011-11-06 01:15:00 -0700
1012 // // nov06.trans is 2011-11-06 01:00:00 -0800
1013 // // nov06.post is 2011-11-06 01:15:00 -0800
1014 TimeInfo At(CivilSecond ct) const;
1015
1016 // TimeZone::NextTransition()
1017 // TimeZone::PrevTransition()
1018 //
1019 // Finds the time of the next/previous offset change in this time zone.
1020 //
1021 // By definition, `NextTransition(t, &trans)` returns false when `t` is
1022 // `InfiniteFuture()`, and `PrevTransition(t, &trans)` returns false
1023 // when `t` is `InfinitePast()`. If the zone has no transitions, the
1024 // result will also be false no matter what the argument.
1025 //
1026 // Otherwise, when `t` is `InfinitePast()`, `NextTransition(t, &trans)`
1027 // returns true and sets `trans` to the first recorded transition. Chains
1028 // of calls to `NextTransition()/PrevTransition()` will eventually return
1029 // false, but it is unspecified exactly when `NextTransition(t, &trans)`
1030 // jumps to false, or what time is set by `PrevTransition(t, &trans)` for
1031 // a very distant `t`.
1032 //
1033 // Note: Enumeration of time-zone transitions is for informational purposes
1034 // only. Modern time-related code should not care about when offset changes
1035 // occur.
1036 //
1037 // Example:
1038 // absl::TimeZone nyc;
1039 // if (!absl::LoadTimeZone("America/New_York", &nyc)) { ... }
1040 // const auto now = absl::Now();
1041 // auto t = absl::InfinitePast();
1042 // absl::TimeZone::CivilTransition trans;
1043 // while (t <= now && nyc.NextTransition(t, &trans)) {
1044 // // transition: trans.from -> trans.to
1045 // t = nyc.At(trans.to).trans;
1046 // }
1047 struct CivilTransition {
1048 CivilSecond from; // the civil time we jump from
1049 CivilSecond to; // the civil time we jump to
1050 };
1051 bool NextTransition(Time t, CivilTransition* trans) const;
1052 bool PrevTransition(Time t, CivilTransition* trans) const;
1053
1054 template <typename H>
AbslHashValue(H h,TimeZone tz)1055 friend H AbslHashValue(H h, TimeZone tz) {
1056 return H::combine(std::move(h), tz.cz_);
1057 }
1058
1059 private:
1060 friend bool operator==(TimeZone a, TimeZone b) { return a.cz_ == b.cz_; }
1061 friend bool operator!=(TimeZone a, TimeZone b) { return a.cz_ != b.cz_; }
1062 friend std::ostream& operator<<(std::ostream& os, TimeZone tz) {
1063 return os << tz.name();
1064 }
1065
1066 time_internal::cctz::time_zone cz_;
1067 };
1068
1069 // LoadTimeZone()
1070 //
1071 // Loads the named zone. May perform I/O on the initial load of the named
1072 // zone. If the name is invalid, or some other kind of error occurs, returns
1073 // `false` and `*tz` is set to the UTC time zone.
LoadTimeZone(absl::string_view name,TimeZone * tz)1074 inline bool LoadTimeZone(absl::string_view name, TimeZone* tz) {
1075 if (name == "localtime") {
1076 *tz = TimeZone(time_internal::cctz::local_time_zone());
1077 return true;
1078 }
1079 time_internal::cctz::time_zone cz;
1080 const bool b = time_internal::cctz::load_time_zone(std::string(name), &cz);
1081 *tz = TimeZone(cz);
1082 return b;
1083 }
1084
1085 // FixedTimeZone()
1086 //
1087 // Returns a TimeZone that is a fixed offset (seconds east) from UTC.
1088 // Note: If the absolute value of the offset is greater than 24 hours
1089 // you'll get UTC (i.e., no offset) instead.
FixedTimeZone(int seconds)1090 inline TimeZone FixedTimeZone(int seconds) {
1091 return TimeZone(
1092 time_internal::cctz::fixed_time_zone(std::chrono::seconds(seconds)));
1093 }
1094
1095 // UTCTimeZone()
1096 //
1097 // Convenience method returning the UTC time zone.
UTCTimeZone()1098 inline TimeZone UTCTimeZone() {
1099 return TimeZone(time_internal::cctz::utc_time_zone());
1100 }
1101
1102 // LocalTimeZone()
1103 //
1104 // Convenience method returning the local time zone, or UTC if there is
1105 // no configured local zone. Warning: Be wary of using LocalTimeZone(),
1106 // and particularly so in a server process, as the zone configured for the
1107 // local machine should be irrelevant. Prefer an explicit zone name.
LocalTimeZone()1108 inline TimeZone LocalTimeZone() {
1109 return TimeZone(time_internal::cctz::local_time_zone());
1110 }
1111
1112 // ToCivilSecond()
1113 // ToCivilMinute()
1114 // ToCivilHour()
1115 // ToCivilDay()
1116 // ToCivilMonth()
1117 // ToCivilYear()
1118 //
1119 // Helpers for TimeZone::At(Time) to return particularly aligned civil times.
1120 //
1121 // Example:
1122 //
1123 // absl::Time t = ...;
1124 // absl::TimeZone tz = ...;
1125 // const auto cd = absl::ToCivilDay(t, tz);
ToCivilSecond(Time t,TimeZone tz)1126 inline CivilSecond ToCivilSecond(Time t, TimeZone tz) {
1127 return tz.At(t).cs; // already a CivilSecond
1128 }
ToCivilMinute(Time t,TimeZone tz)1129 inline CivilMinute ToCivilMinute(Time t, TimeZone tz) {
1130 return CivilMinute(tz.At(t).cs);
1131 }
ToCivilHour(Time t,TimeZone tz)1132 inline CivilHour ToCivilHour(Time t, TimeZone tz) {
1133 return CivilHour(tz.At(t).cs);
1134 }
ToCivilDay(Time t,TimeZone tz)1135 inline CivilDay ToCivilDay(Time t, TimeZone tz) {
1136 return CivilDay(tz.At(t).cs);
1137 }
ToCivilMonth(Time t,TimeZone tz)1138 inline CivilMonth ToCivilMonth(Time t, TimeZone tz) {
1139 return CivilMonth(tz.At(t).cs);
1140 }
ToCivilYear(Time t,TimeZone tz)1141 inline CivilYear ToCivilYear(Time t, TimeZone tz) {
1142 return CivilYear(tz.At(t).cs);
1143 }
1144
1145 // FromCivil()
1146 //
1147 // Helper for TimeZone::At(CivilSecond) that provides "order-preserving
1148 // semantics." If the civil time maps to a unique time, that time is
1149 // returned. If the civil time is repeated in the given time zone, the
1150 // time using the pre-transition offset is returned. Otherwise, the
1151 // civil time is skipped in the given time zone, and the transition time
1152 // is returned. This means that for any two civil times, ct1 and ct2,
1153 // (ct1 < ct2) => (FromCivil(ct1) <= FromCivil(ct2)), the equal case
1154 // being when two non-existent civil times map to the same transition time.
1155 //
1156 // Note: Accepts civil times of any alignment.
FromCivil(CivilSecond ct,TimeZone tz)1157 inline Time FromCivil(CivilSecond ct, TimeZone tz) {
1158 const auto ti = tz.At(ct);
1159 if (ti.kind == TimeZone::TimeInfo::SKIPPED) return ti.trans;
1160 return ti.pre;
1161 }
1162
1163 // TimeConversion
1164 //
1165 // An `absl::TimeConversion` represents the conversion of year, month, day,
1166 // hour, minute, and second values (i.e., a civil time), in a particular
1167 // `absl::TimeZone`, to a time instant (an absolute time), as returned by
1168 // `absl::ConvertDateTime()`. Legacy version of `absl::TimeZone::TimeInfo`.
1169 //
1170 // Deprecated. Use `absl::TimeZone::TimeInfo`.
1171 struct
1172 TimeConversion {
1173 Time pre; // time calculated using the pre-transition offset
1174 Time trans; // when the civil-time discontinuity occurred
1175 Time post; // time calculated using the post-transition offset
1176
1177 enum Kind {
1178 UNIQUE, // the civil time was singular (pre == trans == post)
1179 SKIPPED, // the civil time did not exist
1180 REPEATED, // the civil time was ambiguous
1181 };
1182 Kind kind;
1183
1184 bool normalized; // input values were outside their valid ranges
1185 };
1186
1187 // ConvertDateTime()
1188 //
1189 // Legacy version of `absl::TimeZone::At(absl::CivilSecond)` that takes
1190 // the civil time as six, separate values (YMDHMS).
1191 //
1192 // The input month, day, hour, minute, and second values can be outside
1193 // of their valid ranges, in which case they will be "normalized" during
1194 // the conversion.
1195 //
1196 // Example:
1197 //
1198 // // "October 32" normalizes to "November 1".
1199 // absl::TimeConversion tc =
1200 // absl::ConvertDateTime(2013, 10, 32, 8, 30, 0, lax);
1201 // // tc.kind == TimeConversion::UNIQUE && tc.normalized == true
1202 // // absl::ToCivilDay(tc.pre, tz).month() == 11
1203 // // absl::ToCivilDay(tc.pre, tz).day() == 1
1204 //
1205 // Deprecated. Use `absl::TimeZone::At(CivilSecond)`.
1206 TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour,
1207 int min, int sec, TimeZone tz);
1208
1209 // FromDateTime()
1210 //
1211 // A convenience wrapper for `absl::ConvertDateTime()` that simply returns
1212 // the "pre" `absl::Time`. That is, the unique result, or the instant that
1213 // is correct using the pre-transition offset (as if the transition never
1214 // happened).
1215 //
1216 // Example:
1217 //
1218 // absl::Time t = absl::FromDateTime(2017, 9, 26, 9, 30, 0, lax);
1219 // // t = 2017-09-26 09:30:00 -0700
1220 //
1221 // Deprecated. Use `absl::FromCivil(CivilSecond, TimeZone)`. Note that the
1222 // behavior of `FromCivil()` differs from `FromDateTime()` for skipped civil
1223 // times. If you care about that see `absl::TimeZone::At(absl::CivilSecond)`.
FromDateTime(int64_t year,int mon,int day,int hour,int min,int sec,TimeZone tz)1224 inline Time FromDateTime(int64_t year, int mon, int day, int hour,
1225 int min, int sec, TimeZone tz) {
1226 return ConvertDateTime(year, mon, day, hour, min, sec, tz).pre;
1227 }
1228
1229 // FromTM()
1230 //
1231 // Converts the `tm_year`, `tm_mon`, `tm_mday`, `tm_hour`, `tm_min`, and
1232 // `tm_sec` fields to an `absl::Time` using the given time zone. See ctime(3)
1233 // for a description of the expected values of the tm fields. If the civil time
1234 // is unique (see `absl::TimeZone::At(absl::CivilSecond)` above), the matching
1235 // time instant is returned. Otherwise, the `tm_isdst` field is consulted to
1236 // choose between the possible results. For a repeated civil time, `tm_isdst !=
1237 // 0` returns the matching DST instant, while `tm_isdst == 0` returns the
1238 // matching non-DST instant. For a skipped civil time there is no matching
1239 // instant, so `tm_isdst != 0` returns the DST instant, and `tm_isdst == 0`
1240 // returns the non-DST instant, that would have matched if the transition never
1241 // happened.
1242 Time FromTM(const struct tm& tm, TimeZone tz);
1243
1244 // ToTM()
1245 //
1246 // Converts the given `absl::Time` to a struct tm using the given time zone.
1247 // See ctime(3) for a description of the values of the tm fields.
1248 struct tm ToTM(Time t, TimeZone tz);
1249
1250 // RFC3339_full
1251 // RFC3339_sec
1252 //
1253 // FormatTime()/ParseTime() format specifiers for RFC3339 date/time strings,
1254 // with trailing zeros trimmed or with fractional seconds omitted altogether.
1255 //
1256 // Note that RFC3339_sec[] matches an ISO 8601 extended format for date and
1257 // time with UTC offset. Also note the use of "%Y": RFC3339 mandates that
1258 // years have exactly four digits, but we allow them to take their natural
1259 // width.
1260 ABSL_DLL extern const char RFC3339_full[]; // %Y-%m-%d%ET%H:%M:%E*S%Ez
1261 ABSL_DLL extern const char RFC3339_sec[]; // %Y-%m-%d%ET%H:%M:%S%Ez
1262
1263 // RFC1123_full
1264 // RFC1123_no_wday
1265 //
1266 // FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings.
1267 ABSL_DLL extern const char RFC1123_full[]; // %a, %d %b %E4Y %H:%M:%S %z
1268 ABSL_DLL extern const char RFC1123_no_wday[]; // %d %b %E4Y %H:%M:%S %z
1269
1270 // FormatTime()
1271 //
1272 // Formats the given `absl::Time` in the `absl::TimeZone` according to the
1273 // provided format string. Uses strftime()-like formatting options, with
1274 // the following extensions:
1275 //
1276 // - %Ez - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
1277 // - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
1278 // - %E#S - Seconds with # digits of fractional precision
1279 // - %E*S - Seconds with full fractional precision (a literal '*')
1280 // - %E#f - Fractional seconds with # digits of precision
1281 // - %E*f - Fractional seconds with full precision (a literal '*')
1282 // - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
1283 // - %ET - The RFC3339 "date-time" separator "T"
1284 //
1285 // Note that %E0S behaves like %S, and %E0f produces no characters. In
1286 // contrast %E*f always produces at least one digit, which may be '0'.
1287 //
1288 // Note that %Y produces as many characters as it takes to fully render the
1289 // year. A year outside of [-999:9999] when formatted with %E4Y will produce
1290 // more than four characters, just like %Y.
1291 //
1292 // We recommend that format strings include the UTC offset (%z, %Ez, or %E*z)
1293 // so that the result uniquely identifies a time instant.
1294 //
1295 // Example:
1296 //
1297 // absl::CivilSecond cs(2013, 1, 2, 3, 4, 5);
1298 // absl::Time t = absl::FromCivil(cs, lax);
1299 // std::string f = absl::FormatTime("%H:%M:%S", t, lax); // "03:04:05"
1300 // f = absl::FormatTime("%H:%M:%E3S", t, lax); // "03:04:05.000"
1301 //
1302 // Note: If the given `absl::Time` is `absl::InfiniteFuture()`, the returned
1303 // string will be exactly "infinite-future". If the given `absl::Time` is
1304 // `absl::InfinitePast()`, the returned string will be exactly "infinite-past".
1305 // In both cases the given format string and `absl::TimeZone` are ignored.
1306 //
1307 std::string FormatTime(absl::string_view format, Time t, TimeZone tz);
1308
1309 // Convenience functions that format the given time using the RFC3339_full
1310 // format. The first overload uses the provided TimeZone, while the second
1311 // uses LocalTimeZone().
1312 std::string FormatTime(Time t, TimeZone tz);
1313 std::string FormatTime(Time t);
1314
1315 // Output stream operator.
1316 inline std::ostream& operator<<(std::ostream& os, Time t) {
1317 return os << FormatTime(t);
1318 }
1319
1320 // ParseTime()
1321 //
1322 // Parses an input string according to the provided format string and
1323 // returns the corresponding `absl::Time`. Uses strftime()-like formatting
1324 // options, with the same extensions as FormatTime(), but with the
1325 // exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f. %Ez
1326 // and %E*z also accept the same inputs, which (along with %z) includes
1327 // 'z' and 'Z' as synonyms for +00:00. %ET accepts either 'T' or 't'.
1328 //
1329 // %Y consumes as many numeric characters as it can, so the matching data
1330 // should always be terminated with a non-numeric. %E4Y always consumes
1331 // exactly four characters, including any sign.
1332 //
1333 // Unspecified fields are taken from the default date and time of ...
1334 //
1335 // "1970-01-01 00:00:00.0 +0000"
1336 //
1337 // For example, parsing a string of "15:45" (%H:%M) will return an absl::Time
1338 // that represents "1970-01-01 15:45:00.0 +0000".
1339 //
1340 // Note that since ParseTime() returns time instants, it makes the most sense
1341 // to parse fully-specified date/time strings that include a UTC offset (%z,
1342 // %Ez, or %E*z).
1343 //
1344 // Note also that `absl::ParseTime()` only heeds the fields year, month, day,
1345 // hour, minute, (fractional) second, and UTC offset. Other fields, like
1346 // weekday (%a or %A), while parsed for syntactic validity, are ignored
1347 // in the conversion.
1348 //
1349 // Date and time fields that are out-of-range will be treated as errors
1350 // rather than normalizing them like `absl::CivilSecond` does. For example,
1351 // it is an error to parse the date "Oct 32, 2013" because 32 is out of range.
1352 //
1353 // A leap second of ":60" is normalized to ":00" of the following minute
1354 // with fractional seconds discarded. The following table shows how the
1355 // given seconds and subseconds will be parsed:
1356 //
1357 // "59.x" -> 59.x // exact
1358 // "60.x" -> 00.0 // normalized
1359 // "00.x" -> 00.x // exact
1360 //
1361 // Errors are indicated by returning false and assigning an error message
1362 // to the "err" out param if it is non-null.
1363 //
1364 // Note: If the input string is exactly "infinite-future", the returned
1365 // `absl::Time` will be `absl::InfiniteFuture()` and `true` will be returned.
1366 // If the input string is "infinite-past", the returned `absl::Time` will be
1367 // `absl::InfinitePast()` and `true` will be returned.
1368 //
1369 bool ParseTime(absl::string_view format, absl::string_view input, Time* time,
1370 std::string* err);
1371
1372 // Like ParseTime() above, but if the format string does not contain a UTC
1373 // offset specification (%z/%Ez/%E*z) then the input is interpreted in the
1374 // given TimeZone. This means that the input, by itself, does not identify a
1375 // unique instant. Being time-zone dependent, it also admits the possibility
1376 // of ambiguity or non-existence, in which case the "pre" time (as defined
1377 // by TimeZone::TimeInfo) is returned. For these reasons we recommend that
1378 // all date/time strings include a UTC offset so they're context independent.
1379 bool ParseTime(absl::string_view format, absl::string_view input, TimeZone tz,
1380 Time* time, std::string* err);
1381
1382 // ============================================================================
1383 // Implementation Details Follow
1384 // ============================================================================
1385
1386 namespace time_internal {
1387
1388 // Creates a Duration with a given representation.
1389 // REQUIRES: hi,lo is a valid representation of a Duration as specified
1390 // in time/duration.cc.
1391 constexpr Duration MakeDuration(int64_t hi, uint32_t lo = 0) {
1392 return Duration(hi, lo);
1393 }
1394
MakeDuration(int64_t hi,int64_t lo)1395 constexpr Duration MakeDuration(int64_t hi, int64_t lo) {
1396 return MakeDuration(hi, static_cast<uint32_t>(lo));
1397 }
1398
1399 // Make a Duration value from a floating-point number, as long as that number
1400 // is in the range [ 0 .. numeric_limits<int64_t>::max ), that is, as long as
1401 // it's positive and can be converted to int64_t without risk of UB.
MakePosDoubleDuration(double n)1402 inline Duration MakePosDoubleDuration(double n) {
1403 const int64_t int_secs = static_cast<int64_t>(n);
1404 const uint32_t ticks = static_cast<uint32_t>(
1405 std::round((n - static_cast<double>(int_secs)) * kTicksPerSecond));
1406 return ticks < kTicksPerSecond
1407 ? MakeDuration(int_secs, ticks)
1408 : MakeDuration(int_secs + 1, ticks - kTicksPerSecond);
1409 }
1410
1411 // Creates a normalized Duration from an almost-normalized (sec,ticks)
1412 // pair. sec may be positive or negative. ticks must be in the range
1413 // -kTicksPerSecond < *ticks < kTicksPerSecond. If ticks is negative it
1414 // will be normalized to a positive value in the resulting Duration.
MakeNormalizedDuration(int64_t sec,int64_t ticks)1415 constexpr Duration MakeNormalizedDuration(int64_t sec, int64_t ticks) {
1416 return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
1417 : MakeDuration(sec, ticks);
1418 }
1419
1420 // Provide access to the Duration representation.
GetRepHi(Duration d)1421 constexpr int64_t GetRepHi(Duration d) { return d.rep_hi_; }
GetRepLo(Duration d)1422 constexpr uint32_t GetRepLo(Duration d) { return d.rep_lo_; }
1423
1424 // Returns true iff d is positive or negative infinity.
IsInfiniteDuration(Duration d)1425 constexpr bool IsInfiniteDuration(Duration d) { return GetRepLo(d) == ~0U; }
1426
1427 // Returns an infinite Duration with the opposite sign.
1428 // REQUIRES: IsInfiniteDuration(d)
OppositeInfinity(Duration d)1429 constexpr Duration OppositeInfinity(Duration d) {
1430 return GetRepHi(d) < 0
1431 ? MakeDuration((std::numeric_limits<int64_t>::max)(), ~0U)
1432 : MakeDuration((std::numeric_limits<int64_t>::min)(), ~0U);
1433 }
1434
1435 // Returns (-n)-1 (equivalently -(n+1)) without avoidable overflow.
NegateAndSubtractOne(int64_t n)1436 constexpr int64_t NegateAndSubtractOne(int64_t n) {
1437 // Note: Good compilers will optimize this expression to ~n when using
1438 // a two's-complement representation (which is required for int64_t).
1439 return (n < 0) ? -(n + 1) : (-n) - 1;
1440 }
1441
1442 // Map between a Time and a Duration since the Unix epoch. Note that these
1443 // functions depend on the above mentioned choice of the Unix epoch for the
1444 // Time representation (and both need to be Time friends). Without this
1445 // knowledge, we would need to add-in/subtract-out UnixEpoch() respectively.
FromUnixDuration(Duration d)1446 constexpr Time FromUnixDuration(Duration d) { return Time(d); }
ToUnixDuration(Time t)1447 constexpr Duration ToUnixDuration(Time t) { return t.rep_; }
1448
1449 template <std::intmax_t N>
FromInt64(int64_t v,std::ratio<1,N>)1450 constexpr Duration FromInt64(int64_t v, std::ratio<1, N>) {
1451 static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
1452 // Subsecond ratios cannot overflow.
1453 return MakeNormalizedDuration(
1454 v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
1455 }
FromInt64(int64_t v,std::ratio<60>)1456 constexpr Duration FromInt64(int64_t v, std::ratio<60>) {
1457 return (v <= (std::numeric_limits<int64_t>::max)() / 60 &&
1458 v >= (std::numeric_limits<int64_t>::min)() / 60)
1459 ? MakeDuration(v * 60)
1460 : v > 0 ? InfiniteDuration() : -InfiniteDuration();
1461 }
FromInt64(int64_t v,std::ratio<3600>)1462 constexpr Duration FromInt64(int64_t v, std::ratio<3600>) {
1463 return (v <= (std::numeric_limits<int64_t>::max)() / 3600 &&
1464 v >= (std::numeric_limits<int64_t>::min)() / 3600)
1465 ? MakeDuration(v * 3600)
1466 : v > 0 ? InfiniteDuration() : -InfiniteDuration();
1467 }
1468
1469 // IsValidRep64<T>(0) is true if the expression `int64_t{std::declval<T>()}` is
1470 // valid. That is, if a T can be assigned to an int64_t without narrowing.
1471 template <typename T>
1472 constexpr auto IsValidRep64(int) -> decltype(int64_t{std::declval<T>()} == 0) {
1473 return true;
1474 }
1475 template <typename T>
1476 constexpr auto IsValidRep64(char) -> bool {
1477 return false;
1478 }
1479
1480 // Converts a std::chrono::duration to an absl::Duration.
1481 template <typename Rep, typename Period>
FromChrono(const std::chrono::duration<Rep,Period> & d)1482 constexpr Duration FromChrono(const std::chrono::duration<Rep, Period>& d) {
1483 static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
1484 return FromInt64(int64_t{d.count()}, Period{});
1485 }
1486
1487 template <typename Ratio>
ToInt64(Duration d,Ratio)1488 int64_t ToInt64(Duration d, Ratio) {
1489 // Note: This may be used on MSVC, which may have a system_clock period of
1490 // std::ratio<1, 10 * 1000 * 1000>
1491 return ToInt64Seconds(d * Ratio::den / Ratio::num);
1492 }
1493 // Fastpath implementations for the 6 common duration units.
ToInt64(Duration d,std::nano)1494 inline int64_t ToInt64(Duration d, std::nano) {
1495 return ToInt64Nanoseconds(d);
1496 }
ToInt64(Duration d,std::micro)1497 inline int64_t ToInt64(Duration d, std::micro) {
1498 return ToInt64Microseconds(d);
1499 }
ToInt64(Duration d,std::milli)1500 inline int64_t ToInt64(Duration d, std::milli) {
1501 return ToInt64Milliseconds(d);
1502 }
ToInt64(Duration d,std::ratio<1>)1503 inline int64_t ToInt64(Duration d, std::ratio<1>) {
1504 return ToInt64Seconds(d);
1505 }
ToInt64(Duration d,std::ratio<60>)1506 inline int64_t ToInt64(Duration d, std::ratio<60>) {
1507 return ToInt64Minutes(d);
1508 }
ToInt64(Duration d,std::ratio<3600>)1509 inline int64_t ToInt64(Duration d, std::ratio<3600>) {
1510 return ToInt64Hours(d);
1511 }
1512
1513 // Converts an absl::Duration to a chrono duration of type T.
1514 template <typename T>
ToChronoDuration(Duration d)1515 T ToChronoDuration(Duration d) {
1516 using Rep = typename T::rep;
1517 using Period = typename T::period;
1518 static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
1519 if (time_internal::IsInfiniteDuration(d))
1520 return d < ZeroDuration() ? (T::min)() : (T::max)();
1521 const auto v = ToInt64(d, Period{});
1522 if (v > (std::numeric_limits<Rep>::max)()) return (T::max)();
1523 if (v < (std::numeric_limits<Rep>::min)()) return (T::min)();
1524 return T{v};
1525 }
1526
1527 } // namespace time_internal
1528
1529 constexpr bool operator<(Duration lhs, Duration rhs) {
1530 return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
1531 ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
1532 : time_internal::GetRepHi(lhs) == (std::numeric_limits<int64_t>::min)()
1533 ? time_internal::GetRepLo(lhs) + 1 <
1534 time_internal::GetRepLo(rhs) + 1
1535 : time_internal::GetRepLo(lhs) < time_internal::GetRepLo(rhs);
1536 }
1537
1538 constexpr bool operator==(Duration lhs, Duration rhs) {
1539 return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
1540 time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
1541 }
1542
1543 constexpr Duration operator-(Duration d) {
1544 // This is a little interesting because of the special cases.
1545 //
1546 // If rep_lo_ is zero, we have it easy; it's safe to negate rep_hi_, we're
1547 // dealing with an integral number of seconds, and the only special case is
1548 // the maximum negative finite duration, which can't be negated.
1549 //
1550 // Infinities stay infinite, and just change direction.
1551 //
1552 // Finally we're in the case where rep_lo_ is non-zero, and we can borrow
1553 // a second's worth of ticks and avoid overflow (as negating int64_t-min + 1
1554 // is safe).
1555 return time_internal::GetRepLo(d) == 0
1556 ? time_internal::GetRepHi(d) ==
1557 (std::numeric_limits<int64_t>::min)()
1558 ? InfiniteDuration()
1559 : time_internal::MakeDuration(-time_internal::GetRepHi(d))
1560 : time_internal::IsInfiniteDuration(d)
1561 ? time_internal::OppositeInfinity(d)
1562 : time_internal::MakeDuration(
1563 time_internal::NegateAndSubtractOne(
1564 time_internal::GetRepHi(d)),
1565 time_internal::kTicksPerSecond -
1566 time_internal::GetRepLo(d));
1567 }
1568
InfiniteDuration()1569 constexpr Duration InfiniteDuration() {
1570 return time_internal::MakeDuration((std::numeric_limits<int64_t>::max)(),
1571 ~0U);
1572 }
1573
FromChrono(const std::chrono::nanoseconds & d)1574 constexpr Duration FromChrono(const std::chrono::nanoseconds& d) {
1575 return time_internal::FromChrono(d);
1576 }
FromChrono(const std::chrono::microseconds & d)1577 constexpr Duration FromChrono(const std::chrono::microseconds& d) {
1578 return time_internal::FromChrono(d);
1579 }
FromChrono(const std::chrono::milliseconds & d)1580 constexpr Duration FromChrono(const std::chrono::milliseconds& d) {
1581 return time_internal::FromChrono(d);
1582 }
FromChrono(const std::chrono::seconds & d)1583 constexpr Duration FromChrono(const std::chrono::seconds& d) {
1584 return time_internal::FromChrono(d);
1585 }
FromChrono(const std::chrono::minutes & d)1586 constexpr Duration FromChrono(const std::chrono::minutes& d) {
1587 return time_internal::FromChrono(d);
1588 }
FromChrono(const std::chrono::hours & d)1589 constexpr Duration FromChrono(const std::chrono::hours& d) {
1590 return time_internal::FromChrono(d);
1591 }
1592
FromUnixNanos(int64_t ns)1593 constexpr Time FromUnixNanos(int64_t ns) {
1594 return time_internal::FromUnixDuration(Nanoseconds(ns));
1595 }
1596
FromUnixMicros(int64_t us)1597 constexpr Time FromUnixMicros(int64_t us) {
1598 return time_internal::FromUnixDuration(Microseconds(us));
1599 }
1600
FromUnixMillis(int64_t ms)1601 constexpr Time FromUnixMillis(int64_t ms) {
1602 return time_internal::FromUnixDuration(Milliseconds(ms));
1603 }
1604
FromUnixSeconds(int64_t s)1605 constexpr Time FromUnixSeconds(int64_t s) {
1606 return time_internal::FromUnixDuration(Seconds(s));
1607 }
1608
FromTimeT(time_t t)1609 constexpr Time FromTimeT(time_t t) {
1610 return time_internal::FromUnixDuration(Seconds(t));
1611 }
1612
1613 ABSL_NAMESPACE_END
1614 } // namespace absl
1615
1616 #endif // ABSL_TIME_TIME_H_
1617