Coverage Report

Created: 2024-09-23 06:29

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