libstdc++
chrono
Go to the documentation of this file.
1 // <chrono> -*- C++ -*-
2 
3 // Copyright (C) 2008-2020 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file include/chrono
26  * This is a Standard C++ Library header.
27  * @ingroup chrono
28  */
29 
30 #ifndef _GLIBCXX_CHRONO
31 #define _GLIBCXX_CHRONO 1
32 
33 #pragma GCC system_header
34 
35 #if __cplusplus < 201103L
36 # include <bits/c++0x_warning.h>
37 #else
38 
39 #include <ratio>
40 #include <type_traits>
41 #include <limits>
42 #include <ctime>
43 #include <bits/parse_numbers.h> // for literals support.
44 
45 namespace std _GLIBCXX_VISIBILITY(default)
46 {
47 _GLIBCXX_BEGIN_NAMESPACE_VERSION
48 
49  /**
50  * @defgroup chrono Time
51  * @ingroup utilities
52  *
53  * Classes and functions for time.
54  * @{
55  */
56 
57  /** @namespace std::chrono
58  * @brief ISO C++ 2011 namespace for date and time utilities
59  */
60  namespace chrono
61  {
62  template<typename _Rep, typename _Period = ratio<1>>
63  struct duration;
64 
65  template<typename _Clock, typename _Dur = typename _Clock::duration>
66  struct time_point;
67  }
68 
69  // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
70 
71  /// @cond undocumented
72 
73  template<typename _CT, typename _Period1, typename _Period2, typename = void>
74  struct __duration_common_type
75  { };
76 
77  template<typename _CT, typename _Period1, typename _Period2>
78  struct __duration_common_type<_CT, _Period1, _Period2,
79  __void_t<typename _CT::type>>
80  {
81  private:
82  using __gcd_num = __static_gcd<_Period1::num, _Period2::num>;
83  using __gcd_den = __static_gcd<_Period1::den, _Period2::den>;
84  using __cr = typename _CT::type;
85  using __r = ratio<__gcd_num::value,
86  (_Period1::den / __gcd_den::value) * _Period2::den>;
87 
88  public:
89  using type = chrono::duration<__cr, __r>;
90  };
91 
92  template<typename _Period1, typename _Period2>
93  struct __duration_common_type<__failure_type, _Period1, _Period2>
94  { typedef __failure_type type; };
95 
96  /// @endcond
97 
98  /// Specialization of common_type for chrono::duration types.
99  /// @relates duration
100  template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
101  struct common_type<chrono::duration<_Rep1, _Period1>,
102  chrono::duration<_Rep2, _Period2>>
103  : __duration_common_type<common_type<_Rep1, _Rep2>, _Period1, _Period2>
104  { };
105 
106  // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
107 
108  /// @cond undocumented
109 
110  template<typename _CT, typename _Clock, typename = void>
111  struct __timepoint_common_type
112  { };
113 
114  template<typename _CT, typename _Clock>
115  struct __timepoint_common_type<_CT, _Clock, __void_t<typename _CT::type>>
116  {
117  using type = chrono::time_point<_Clock, typename _CT::type>;
118  };
119 
120  /// @endcond
121 
122  /// Specialization of common_type for chrono::time_point types.
123  /// @relates time_point
124  template<typename _Clock, typename _Duration1, typename _Duration2>
125  struct common_type<chrono::time_point<_Clock, _Duration1>,
126  chrono::time_point<_Clock, _Duration2>>
127  : __timepoint_common_type<common_type<_Duration1, _Duration2>, _Clock>
128  { };
129 
130  // @} group chrono
131 
132  namespace chrono
133  {
134  /// @addtogroup chrono
135  /// @{
136 
137  /// @cond undocumented
138 
139  // Primary template for duration_cast impl.
140  template<typename _ToDur, typename _CF, typename _CR,
141  bool _NumIsOne = false, bool _DenIsOne = false>
142  struct __duration_cast_impl
143  {
144  template<typename _Rep, typename _Period>
145  static constexpr _ToDur
146  __cast(const duration<_Rep, _Period>& __d)
147  {
148  typedef typename _ToDur::rep __to_rep;
149  return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
150  * static_cast<_CR>(_CF::num)
151  / static_cast<_CR>(_CF::den)));
152  }
153  };
154 
155  template<typename _ToDur, typename _CF, typename _CR>
156  struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
157  {
158  template<typename _Rep, typename _Period>
159  static constexpr _ToDur
160  __cast(const duration<_Rep, _Period>& __d)
161  {
162  typedef typename _ToDur::rep __to_rep;
163  return _ToDur(static_cast<__to_rep>(__d.count()));
164  }
165  };
166 
167  template<typename _ToDur, typename _CF, typename _CR>
168  struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
169  {
170  template<typename _Rep, typename _Period>
171  static constexpr _ToDur
172  __cast(const duration<_Rep, _Period>& __d)
173  {
174  typedef typename _ToDur::rep __to_rep;
175  return _ToDur(static_cast<__to_rep>(
176  static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
177  }
178  };
179 
180  template<typename _ToDur, typename _CF, typename _CR>
181  struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
182  {
183  template<typename _Rep, typename _Period>
184  static constexpr _ToDur
185  __cast(const duration<_Rep, _Period>& __d)
186  {
187  typedef typename _ToDur::rep __to_rep;
188  return _ToDur(static_cast<__to_rep>(
189  static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
190  }
191  };
192 
193  template<typename _Tp>
194  struct __is_duration
195  : std::false_type
196  { };
197 
198  template<typename _Rep, typename _Period>
199  struct __is_duration<duration<_Rep, _Period>>
200  : std::true_type
201  { };
202 
203  template<typename _Tp>
204  using __enable_if_is_duration
205  = typename enable_if<__is_duration<_Tp>::value, _Tp>::type;
206 
207  template<typename _Tp>
208  using __disable_if_is_duration
209  = typename enable_if<!__is_duration<_Tp>::value, _Tp>::type;
210 
211  /// @endcond
212 
213  /// duration_cast
214  template<typename _ToDur, typename _Rep, typename _Period>
215  constexpr __enable_if_is_duration<_ToDur>
216  duration_cast(const duration<_Rep, _Period>& __d)
217  {
218  typedef typename _ToDur::period __to_period;
219  typedef typename _ToDur::rep __to_rep;
220  typedef ratio_divide<_Period, __to_period> __cf;
221  typedef typename common_type<__to_rep, _Rep, intmax_t>::type
222  __cr;
223  typedef __duration_cast_impl<_ToDur, __cf, __cr,
224  __cf::num == 1, __cf::den == 1> __dc;
225  return __dc::__cast(__d);
226  }
227 
228  /// treat_as_floating_point
229  template<typename _Rep>
230  struct treat_as_floating_point
231  : is_floating_point<_Rep>
232  { };
233 
234 #if __cplusplus > 201402L
235  template <typename _Rep>
236  inline constexpr bool treat_as_floating_point_v =
237  treat_as_floating_point<_Rep>::value;
238 #endif // C++17
239 
240 #if __cplusplus >= 201703L
241 # define __cpp_lib_chrono 201611
242 
243  template<typename _ToDur, typename _Rep, typename _Period>
244  constexpr __enable_if_is_duration<_ToDur>
245  floor(const duration<_Rep, _Period>& __d)
246  {
247  auto __to = chrono::duration_cast<_ToDur>(__d);
248  if (__to > __d)
249  return __to - _ToDur{1};
250  return __to;
251  }
252 
253  template<typename _ToDur, typename _Rep, typename _Period>
254  constexpr __enable_if_is_duration<_ToDur>
255  ceil(const duration<_Rep, _Period>& __d)
256  {
257  auto __to = chrono::duration_cast<_ToDur>(__d);
258  if (__to < __d)
259  return __to + _ToDur{1};
260  return __to;
261  }
262 
263  template <typename _ToDur, typename _Rep, typename _Period>
264  constexpr enable_if_t<
265  __and_<__is_duration<_ToDur>,
266  __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
267  _ToDur>
268  round(const duration<_Rep, _Period>& __d)
269  {
270  _ToDur __t0 = chrono::floor<_ToDur>(__d);
271  _ToDur __t1 = __t0 + _ToDur{1};
272  auto __diff0 = __d - __t0;
273  auto __diff1 = __t1 - __d;
274  if (__diff0 == __diff1)
275  {
276  if (__t0.count() & 1)
277  return __t1;
278  return __t0;
279  }
280  else if (__diff0 < __diff1)
281  return __t0;
282  return __t1;
283  }
284 
285  template<typename _Rep, typename _Period>
286  constexpr
287  enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>>
288  abs(duration<_Rep, _Period> __d)
289  {
290  if (__d >= __d.zero())
291  return __d;
292  return -__d;
293  }
294 #endif // C++17
295 
296  /// duration_values
297  template<typename _Rep>
298  struct duration_values
299  {
300  static constexpr _Rep
301  zero() noexcept
302  { return _Rep(0); }
303 
304  static constexpr _Rep
305  max() noexcept
306  { return numeric_limits<_Rep>::max(); }
307 
308  static constexpr _Rep
309  min() noexcept
310  { return numeric_limits<_Rep>::lowest(); }
311  };
312 
313  /// @cond undocumented
314 
315  template<typename _Tp>
316  struct __is_ratio
317  : std::false_type
318  { };
319 
320  template<intmax_t _Num, intmax_t _Den>
321  struct __is_ratio<ratio<_Num, _Den>>
322  : std::true_type
323  { };
324 
325  /// @endcond
326 
327  /// duration
328  template<typename _Rep, typename _Period>
329  struct duration
330  {
331  private:
332  template<typename _Rep2>
333  using __is_float = treat_as_floating_point<_Rep2>;
334 
335  // _Period2 is an exact multiple of _Period
336  template<typename _Period2>
337  using __is_harmonic
338  = __bool_constant<ratio_divide<_Period2, _Period>::den == 1>;
339 
340  public:
341 
342  typedef _Rep rep;
343  typedef _Period period;
344 
345  static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
346  static_assert(__is_ratio<_Period>::value,
347  "period must be a specialization of ratio");
348  static_assert(_Period::num > 0, "period must be positive");
349 
350  // 20.11.5.1 construction / copy / destroy
351  constexpr duration() = default;
352 
353  duration(const duration&) = default;
354 
355  // _GLIBCXX_RESOLVE_LIB_DEFECTS
356  // 3050. Conversion specification problem in chrono::duration
357  template<typename _Rep2, typename = _Require<
358  is_convertible<const _Rep2&, rep>,
359  __or_<__is_float<rep>, __not_<__is_float<_Rep2>>>>>
360  constexpr explicit duration(const _Rep2& __rep)
361  : __r(static_cast<rep>(__rep)) { }
362 
363  template<typename _Rep2, typename _Period2, typename = _Require<
364  __or_<__is_float<rep>,
365  __and_<__is_harmonic<_Period2>,
366  __not_<__is_float<_Rep2>>>>>>
367  constexpr duration(const duration<_Rep2, _Period2>& __d)
368  : __r(duration_cast<duration>(__d).count()) { }
369 
370  ~duration() = default;
371  duration& operator=(const duration&) = default;
372 
373  // 20.11.5.2 observer
374  constexpr rep
375  count() const
376  { return __r; }
377 
378  // 20.11.5.3 arithmetic
379  constexpr duration
380  operator+() const
381  { return *this; }
382 
383  constexpr duration
384  operator-() const
385  { return duration(-__r); }
386 
387  _GLIBCXX17_CONSTEXPR duration&
388  operator++()
389  {
390  ++__r;
391  return *this;
392  }
393 
394  _GLIBCXX17_CONSTEXPR duration
395  operator++(int)
396  { return duration(__r++); }
397 
398  _GLIBCXX17_CONSTEXPR duration&
399  operator--()
400  {
401  --__r;
402  return *this;
403  }
404 
405  _GLIBCXX17_CONSTEXPR duration
406  operator--(int)
407  { return duration(__r--); }
408 
409  _GLIBCXX17_CONSTEXPR duration&
410  operator+=(const duration& __d)
411  {
412  __r += __d.count();
413  return *this;
414  }
415 
416  _GLIBCXX17_CONSTEXPR duration&
417  operator-=(const duration& __d)
418  {
419  __r -= __d.count();
420  return *this;
421  }
422 
423  _GLIBCXX17_CONSTEXPR duration&
424  operator*=(const rep& __rhs)
425  {
426  __r *= __rhs;
427  return *this;
428  }
429 
430  _GLIBCXX17_CONSTEXPR duration&
431  operator/=(const rep& __rhs)
432  {
433  __r /= __rhs;
434  return *this;
435  }
436 
437  // DR 934.
438  template<typename _Rep2 = rep>
439  _GLIBCXX17_CONSTEXPR
440  typename enable_if<!treat_as_floating_point<_Rep2>::value,
441  duration&>::type
442  operator%=(const rep& __rhs)
443  {
444  __r %= __rhs;
445  return *this;
446  }
447 
448  template<typename _Rep2 = rep>
449  _GLIBCXX17_CONSTEXPR
450  typename enable_if<!treat_as_floating_point<_Rep2>::value,
451  duration&>::type
452  operator%=(const duration& __d)
453  {
454  __r %= __d.count();
455  return *this;
456  }
457 
458  // 20.11.5.4 special values
459  static constexpr duration
460  zero() noexcept
461  { return duration(duration_values<rep>::zero()); }
462 
463  static constexpr duration
464  min() noexcept
465  { return duration(duration_values<rep>::min()); }
466 
467  static constexpr duration
468  max() noexcept
469  { return duration(duration_values<rep>::max()); }
470 
471  private:
472  rep __r;
473  };
474 
475  /// @relates duration @{
476 
477  /// The sum of two durations.
478  template<typename _Rep1, typename _Period1,
479  typename _Rep2, typename _Period2>
480  constexpr typename common_type<duration<_Rep1, _Period1>,
481  duration<_Rep2, _Period2>>::type
482  operator+(const duration<_Rep1, _Period1>& __lhs,
483  const duration<_Rep2, _Period2>& __rhs)
484  {
485  typedef duration<_Rep1, _Period1> __dur1;
486  typedef duration<_Rep2, _Period2> __dur2;
487  typedef typename common_type<__dur1,__dur2>::type __cd;
488  return __cd(__cd(__lhs).count() + __cd(__rhs).count());
489  }
490 
491  /// The difference between two durations.
492  template<typename _Rep1, typename _Period1,
493  typename _Rep2, typename _Period2>
494  constexpr typename common_type<duration<_Rep1, _Period1>,
495  duration<_Rep2, _Period2>>::type
496  operator-(const duration<_Rep1, _Period1>& __lhs,
497  const duration<_Rep2, _Period2>& __rhs)
498  {
499  typedef duration<_Rep1, _Period1> __dur1;
500  typedef duration<_Rep2, _Period2> __dur2;
501  typedef typename common_type<__dur1,__dur2>::type __cd;
502  return __cd(__cd(__lhs).count() - __cd(__rhs).count());
503  }
504 
505  /// @}
506 
507  /// @cond undocumented
508 
509  // SFINAE helper to obtain common_type<_Rep1, _Rep2> only if _Rep2
510  // is implicitly convertible to it.
511  // _GLIBCXX_RESOLVE_LIB_DEFECTS
512  // 3050. Conversion specification problem in chrono::duration constructor
513  template<typename _Rep1, typename _Rep2,
514  typename _CRep = typename common_type<_Rep1, _Rep2>::type>
515  using __common_rep_t = typename
516  enable_if<is_convertible<const _Rep2&, _CRep>::value, _CRep>::type;
517 
518  /// @endcond
519 
520  /// @relates duration @{
521 
522  /// Multiply a duration by a scalar value.
523  template<typename _Rep1, typename _Period, typename _Rep2>
524  constexpr duration<__common_rep_t<_Rep1, _Rep2>, _Period>
525  operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
526  {
527  typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
528  __cd;
529  return __cd(__cd(__d).count() * __s);
530  }
531 
532  /// Multiply a duration by a scalar value.
533  template<typename _Rep1, typename _Rep2, typename _Period>
534  constexpr duration<__common_rep_t<_Rep2, _Rep1>, _Period>
535  operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
536  { return __d * __s; }
537 
538  template<typename _Rep1, typename _Period, typename _Rep2>
539  constexpr
540  duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
541  operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
542  {
543  typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
544  __cd;
545  return __cd(__cd(__d).count() / __s);
546  }
547 
548  template<typename _Rep1, typename _Period1,
549  typename _Rep2, typename _Period2>
550  constexpr typename common_type<_Rep1, _Rep2>::type
551  operator/(const duration<_Rep1, _Period1>& __lhs,
552  const duration<_Rep2, _Period2>& __rhs)
553  {
554  typedef duration<_Rep1, _Period1> __dur1;
555  typedef duration<_Rep2, _Period2> __dur2;
556  typedef typename common_type<__dur1,__dur2>::type __cd;
557  return __cd(__lhs).count() / __cd(__rhs).count();
558  }
559 
560  // DR 934.
561  template<typename _Rep1, typename _Period, typename _Rep2>
562  constexpr
563  duration<__common_rep_t<_Rep1, __disable_if_is_duration<_Rep2>>, _Period>
564  operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
565  {
566  typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
567  __cd;
568  return __cd(__cd(__d).count() % __s);
569  }
570 
571  template<typename _Rep1, typename _Period1,
572  typename _Rep2, typename _Period2>
573  constexpr typename common_type<duration<_Rep1, _Period1>,
574  duration<_Rep2, _Period2>>::type
575  operator%(const duration<_Rep1, _Period1>& __lhs,
576  const duration<_Rep2, _Period2>& __rhs)
577  {
578  typedef duration<_Rep1, _Period1> __dur1;
579  typedef duration<_Rep2, _Period2> __dur2;
580  typedef typename common_type<__dur1,__dur2>::type __cd;
581  return __cd(__cd(__lhs).count() % __cd(__rhs).count());
582  }
583 
584  // comparisons
585 
586  template<typename _Rep1, typename _Period1,
587  typename _Rep2, typename _Period2>
588  constexpr bool
589  operator==(const duration<_Rep1, _Period1>& __lhs,
590  const duration<_Rep2, _Period2>& __rhs)
591  {
592  typedef duration<_Rep1, _Period1> __dur1;
593  typedef duration<_Rep2, _Period2> __dur2;
594  typedef typename common_type<__dur1,__dur2>::type __ct;
595  return __ct(__lhs).count() == __ct(__rhs).count();
596  }
597 
598  template<typename _Rep1, typename _Period1,
599  typename _Rep2, typename _Period2>
600  constexpr bool
601  operator<(const duration<_Rep1, _Period1>& __lhs,
602  const duration<_Rep2, _Period2>& __rhs)
603  {
604  typedef duration<_Rep1, _Period1> __dur1;
605  typedef duration<_Rep2, _Period2> __dur2;
606  typedef typename common_type<__dur1,__dur2>::type __ct;
607  return __ct(__lhs).count() < __ct(__rhs).count();
608  }
609 
610  template<typename _Rep1, typename _Period1,
611  typename _Rep2, typename _Period2>
612  constexpr bool
613  operator!=(const duration<_Rep1, _Period1>& __lhs,
614  const duration<_Rep2, _Period2>& __rhs)
615  { return !(__lhs == __rhs); }
616 
617  template<typename _Rep1, typename _Period1,
618  typename _Rep2, typename _Period2>
619  constexpr bool
620  operator<=(const duration<_Rep1, _Period1>& __lhs,
621  const duration<_Rep2, _Period2>& __rhs)
622  { return !(__rhs < __lhs); }
623 
624  template<typename _Rep1, typename _Period1,
625  typename _Rep2, typename _Period2>
626  constexpr bool
627  operator>(const duration<_Rep1, _Period1>& __lhs,
628  const duration<_Rep2, _Period2>& __rhs)
629  { return __rhs < __lhs; }
630 
631  template<typename _Rep1, typename _Period1,
632  typename _Rep2, typename _Period2>
633  constexpr bool
634  operator>=(const duration<_Rep1, _Period1>& __lhs,
635  const duration<_Rep2, _Period2>& __rhs)
636  { return !(__lhs < __rhs); }
637 
638  /// @}
639 
640 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
641 # define _GLIBCXX_CHRONO_INT64_T int64_t
642 #elif defined __INT64_TYPE__
643 # define _GLIBCXX_CHRONO_INT64_T __INT64_TYPE__
644 #else
645  static_assert(std::numeric_limits<unsigned long long>::digits >= 64,
646  "Representation type for nanoseconds must have at least 64 bits");
647 # define _GLIBCXX_CHRONO_INT64_T long long
648 #endif
649 
650  /// nanoseconds
651  typedef duration<_GLIBCXX_CHRONO_INT64_T, nano> nanoseconds;
652 
653  /// microseconds
654  typedef duration<_GLIBCXX_CHRONO_INT64_T, micro> microseconds;
655 
656  /// milliseconds
657  typedef duration<_GLIBCXX_CHRONO_INT64_T, milli> milliseconds;
658 
659  /// seconds
660  typedef duration<_GLIBCXX_CHRONO_INT64_T> seconds;
661 
662  /// minutes
663  typedef duration<_GLIBCXX_CHRONO_INT64_T, ratio< 60>> minutes;
664 
665  /// hours
666  typedef duration<_GLIBCXX_CHRONO_INT64_T, ratio<3600>> hours;
667 
668 #undef _GLIBCXX_CHRONO_INT64_T
669 
670  /// time_point
671  template<typename _Clock, typename _Dur>
672  struct time_point
673  {
674  typedef _Clock clock;
675  typedef _Dur duration;
676  typedef typename duration::rep rep;
677  typedef typename duration::period period;
678 
679  constexpr time_point() : __d(duration::zero())
680  { }
681 
682  constexpr explicit time_point(const duration& __dur)
683  : __d(__dur)
684  { }
685 
686  // conversions
687  template<typename _Dur2,
688  typename = _Require<is_convertible<_Dur2, _Dur>>>
689  constexpr time_point(const time_point<clock, _Dur2>& __t)
690  : __d(__t.time_since_epoch())
691  { }
692 
693  // observer
694  constexpr duration
695  time_since_epoch() const
696  { return __d; }
697 
698  // arithmetic
699  _GLIBCXX17_CONSTEXPR time_point&
700  operator+=(const duration& __dur)
701  {
702  __d += __dur;
703  return *this;
704  }
705 
706  _GLIBCXX17_CONSTEXPR time_point&
707  operator-=(const duration& __dur)
708  {
709  __d -= __dur;
710  return *this;
711  }
712 
713  // special values
714  static constexpr time_point
715  min() noexcept
716  { return time_point(duration::min()); }
717 
718  static constexpr time_point
719  max() noexcept
720  { return time_point(duration::max()); }
721 
722  private:
723  duration __d;
724  };
725 
726  /// time_point_cast
727  template<typename _ToDur, typename _Clock, typename _Dur>
728  constexpr typename enable_if<__is_duration<_ToDur>::value,
729  time_point<_Clock, _ToDur>>::type
730  time_point_cast(const time_point<_Clock, _Dur>& __t)
731  {
732  typedef time_point<_Clock, _ToDur> __time_point;
733  return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
734  }
735 
736 #if __cplusplus > 201402L
737  template<typename _ToDur, typename _Clock, typename _Dur>
738  constexpr
739  enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
740  floor(const time_point<_Clock, _Dur>& __tp)
741  {
742  return time_point<_Clock, _ToDur>{
743  chrono::floor<_ToDur>(__tp.time_since_epoch())};
744  }
745 
746  template<typename _ToDur, typename _Clock, typename _Dur>
747  constexpr
748  enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
749  ceil(const time_point<_Clock, _Dur>& __tp)
750  {
751  return time_point<_Clock, _ToDur>{
752  chrono::ceil<_ToDur>(__tp.time_since_epoch())};
753  }
754 
755  template<typename _ToDur, typename _Clock, typename _Dur>
756  constexpr enable_if_t<
757  __and_<__is_duration<_ToDur>,
758  __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
759  time_point<_Clock, _ToDur>>
760  round(const time_point<_Clock, _Dur>& __tp)
761  {
762  return time_point<_Clock, _ToDur>{
763  chrono::round<_ToDur>(__tp.time_since_epoch())};
764  }
765 #endif // C++17
766 
767  /// @relates time_point @{
768 
769  /// Adjust a time point forwards by the given duration.
770  template<typename _Clock, typename _Dur1,
771  typename _Rep2, typename _Period2>
772  constexpr time_point<_Clock,
773  typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
774  operator+(const time_point<_Clock, _Dur1>& __lhs,
775  const duration<_Rep2, _Period2>& __rhs)
776  {
777  typedef duration<_Rep2, _Period2> __dur2;
778  typedef typename common_type<_Dur1,__dur2>::type __ct;
779  typedef time_point<_Clock, __ct> __time_point;
780  return __time_point(__lhs.time_since_epoch() + __rhs);
781  }
782 
783  /// Adjust a time point forwards by the given duration.
784  template<typename _Rep1, typename _Period1,
785  typename _Clock, typename _Dur2>
786  constexpr time_point<_Clock,
787  typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
788  operator+(const duration<_Rep1, _Period1>& __lhs,
789  const time_point<_Clock, _Dur2>& __rhs)
790  {
791  typedef duration<_Rep1, _Period1> __dur1;
792  typedef typename common_type<__dur1,_Dur2>::type __ct;
793  typedef time_point<_Clock, __ct> __time_point;
794  return __time_point(__rhs.time_since_epoch() + __lhs);
795  }
796 
797  /// Adjust a time point backwards by the given duration.
798  template<typename _Clock, typename _Dur1,
799  typename _Rep2, typename _Period2>
800  constexpr time_point<_Clock,
801  typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
802  operator-(const time_point<_Clock, _Dur1>& __lhs,
803  const duration<_Rep2, _Period2>& __rhs)
804  {
805  typedef duration<_Rep2, _Period2> __dur2;
806  typedef typename common_type<_Dur1,__dur2>::type __ct;
807  typedef time_point<_Clock, __ct> __time_point;
808  return __time_point(__lhs.time_since_epoch() -__rhs);
809  }
810 
811  /// @}
812 
813  /// @relates time_point @{
814 
815  /// The difference between two time points (as a duration)
816  template<typename _Clock, typename _Dur1, typename _Dur2>
817  constexpr typename common_type<_Dur1, _Dur2>::type
818  operator-(const time_point<_Clock, _Dur1>& __lhs,
819  const time_point<_Clock, _Dur2>& __rhs)
820  { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
821 
822  template<typename _Clock, typename _Dur1, typename _Dur2>
823  constexpr bool
824  operator==(const time_point<_Clock, _Dur1>& __lhs,
825  const time_point<_Clock, _Dur2>& __rhs)
826  { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
827 
828  template<typename _Clock, typename _Dur1, typename _Dur2>
829  constexpr bool
830  operator!=(const time_point<_Clock, _Dur1>& __lhs,
831  const time_point<_Clock, _Dur2>& __rhs)
832  { return !(__lhs == __rhs); }
833 
834  template<typename _Clock, typename _Dur1, typename _Dur2>
835  constexpr bool
836  operator<(const time_point<_Clock, _Dur1>& __lhs,
837  const time_point<_Clock, _Dur2>& __rhs)
838  { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
839 
840  template<typename _Clock, typename _Dur1, typename _Dur2>
841  constexpr bool
842  operator<=(const time_point<_Clock, _Dur1>& __lhs,
843  const time_point<_Clock, _Dur2>& __rhs)
844  { return !(__rhs < __lhs); }
845 
846  template<typename _Clock, typename _Dur1, typename _Dur2>
847  constexpr bool
848  operator>(const time_point<_Clock, _Dur1>& __lhs,
849  const time_point<_Clock, _Dur2>& __rhs)
850  { return __rhs < __lhs; }
851 
852  template<typename _Clock, typename _Dur1, typename _Dur2>
853  constexpr bool
854  operator>=(const time_point<_Clock, _Dur1>& __lhs,
855  const time_point<_Clock, _Dur2>& __rhs)
856  { return !(__lhs < __rhs); }
857 
858  // @}
859 
860  // Clocks.
861 
862  // Why nanosecond resolution as the default?
863  // Why have std::system_clock always count in the highest
864  // resolution (ie nanoseconds), even if on some OSes the low 3
865  // or 9 decimal digits will be always zero? This allows later
866  // implementations to change the system_clock::now()
867  // implementation any time to provide better resolution without
868  // changing function signature or units.
869 
870  // To support the (forward) evolution of the library's defined
871  // clocks, wrap inside inline namespace so that the current
872  // defintions of system_clock, steady_clock, and
873  // high_resolution_clock types are uniquely mangled. This way, new
874  // code can use the latests clocks, while the library can contain
875  // compatibility definitions for previous versions. At some
876  // point, when these clocks settle down, the inlined namespaces
877  // can be removed. XXX GLIBCXX_ABI Deprecated
878  inline namespace _V2 {
879 
880  /**
881  * @brief System clock.
882  *
883  * Time returned represents wall time from the system-wide clock.
884  * @ingroup chrono
885  */
886  struct system_clock
887  {
888  typedef chrono::nanoseconds duration;
889  typedef duration::rep rep;
890  typedef duration::period period;
891  typedef chrono::time_point<system_clock, duration> time_point;
892 
893  static_assert(system_clock::duration::min()
894  < system_clock::duration::zero(),
895  "a clock's minimum duration cannot be less than its epoch");
896 
897  static constexpr bool is_steady = false;
898 
899  static time_point
900  now() noexcept;
901 
902  // Map to C API
903  static std::time_t
904  to_time_t(const time_point& __t) noexcept
905  {
906  return std::time_t(duration_cast<chrono::seconds>
907  (__t.time_since_epoch()).count());
908  }
909 
910  static time_point
911  from_time_t(std::time_t __t) noexcept
912  {
913  typedef chrono::time_point<system_clock, seconds> __from;
914  return time_point_cast<system_clock::duration>
915  (__from(chrono::seconds(__t)));
916  }
917  };
918 
919 
920  /**
921  * @brief Monotonic clock
922  *
923  * Time returned has the property of only increasing at a uniform rate.
924  * @ingroup chrono
925  */
926  struct steady_clock
927  {
928  typedef chrono::nanoseconds duration;
929  typedef duration::rep rep;
930  typedef duration::period period;
931  typedef chrono::time_point<steady_clock, duration> time_point;
932 
933  static constexpr bool is_steady = true;
934 
935  static time_point
936  now() noexcept;
937  };
938 
939 
940  /**
941  * @brief Highest-resolution clock
942  *
943  * This is the clock "with the shortest tick period." Alias to
944  * std::system_clock until higher-than-nanosecond definitions
945  * become feasible.
946  * @ingroup chrono
947  */
948  using high_resolution_clock = system_clock;
949 
950  } // end inline namespace _V2
951  // @}
952  } // namespace chrono
953 
954 #if __cplusplus > 201103L
955 
956 #define __cpp_lib_chrono_udls 201304
957 
958  inline namespace literals
959  {
960  /** ISO C++ 2014 namespace for suffixes for duration literals.
961  *
962  * These suffixes can be used to create `chrono::duration` values with
963  * tick periods of hours, minutes, seconds, milliseconds, microseconds
964  * or nanoseconds. For example, `std::chrono::seconds(5)` can be written
965  * as `5s` after making the suffix visible in the current scope.
966  * The suffixes can be made visible by a using-directive or
967  * using-declaration such as:
968  * - `using namespace std::chrono_literals;`
969  * - `using namespace std::literals;`
970  * - `using namespace std::chrono;`
971  * - `using namespace std;`
972  * - `using std::chrono_literals::operator""s;`
973  *
974  * The result of these suffixes on an integer literal is one of the
975  * standard typedefs such as `std::chrono::hours`.
976  * The result on a floating-point literal is a duration type with the
977  * specified tick period and an unspecified floating-point representation,
978  * for example `1.5e2ms` might be equivalent to
979  * `chrono::duration<long double, chrono::milli>(1.5e2)`.
980  *
981  * @ingroup chrono
982  */
983  inline namespace chrono_literals
984  {
985 #pragma GCC diagnostic push
986 #pragma GCC diagnostic ignored "-Wliteral-suffix"
987  /// @cond undocumented
988  template<typename _Dur, char... _Digits>
989  constexpr _Dur __check_overflow()
990  {
991  using _Val = __parse_int::_Parse_int<_Digits...>;
992  constexpr typename _Dur::rep __repval = _Val::value;
993  static_assert(__repval >= 0 && __repval == _Val::value,
994  "literal value cannot be represented by duration type");
995  return _Dur(__repval);
996  }
997  /// @endcond
998 
999  /// Literal suffix for durations representing non-integer hours
1000  constexpr chrono::duration<long double, ratio<3600,1>>
1001  operator""h(long double __hours)
1002  { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
1003 
1004  /// Literal suffix for durations of type `std::chrono::hours`
1005  template <char... _Digits>
1006  constexpr chrono::hours
1007  operator""h()
1008  { return __check_overflow<chrono::hours, _Digits...>(); }
1009 
1010  /// Literal suffix for durations representing non-integer minutes
1011  constexpr chrono::duration<long double, ratio<60,1>>
1012  operator""min(long double __mins)
1013  { return chrono::duration<long double, ratio<60,1>>{__mins}; }
1014 
1015  /// Literal suffix for durations of type `std::chrono::minutes`
1016  template <char... _Digits>
1017  constexpr chrono::minutes
1018  operator""min()
1019  { return __check_overflow<chrono::minutes, _Digits...>(); }
1020 
1021  /// Literal suffix for durations representing non-integer seconds
1022  constexpr chrono::duration<long double>
1023  operator""s(long double __secs)
1024  { return chrono::duration<long double>{__secs}; }
1025 
1026  /// Literal suffix for durations of type `std::chrono::seconds`
1027  template <char... _Digits>
1028  constexpr chrono::seconds
1029  operator""s()
1030  { return __check_overflow<chrono::seconds, _Digits...>(); }
1031 
1032  /// Literal suffix for durations representing non-integer milliseconds
1033  constexpr chrono::duration<long double, milli>
1034  operator""ms(long double __msecs)
1035  { return chrono::duration<long double, milli>{__msecs}; }
1036 
1037  /// Literal suffix for durations of type `std::chrono::milliseconds`
1038  template <char... _Digits>
1039  constexpr chrono::milliseconds
1040  operator""ms()
1041  { return __check_overflow<chrono::milliseconds, _Digits...>(); }
1042 
1043  /// Literal suffix for durations representing non-integer microseconds
1044  constexpr chrono::duration<long double, micro>
1045  operator""us(long double __usecs)
1046  { return chrono::duration<long double, micro>{__usecs}; }
1047 
1048  /// Literal suffix for durations of type `std::chrono::microseconds`
1049  template <char... _Digits>
1050  constexpr chrono::microseconds
1051  operator""us()
1052  { return __check_overflow<chrono::microseconds, _Digits...>(); }
1053 
1054  /// Literal suffix for durations representing non-integer nanoseconds
1055  constexpr chrono::duration<long double, nano>
1056  operator""ns(long double __nsecs)
1057  { return chrono::duration<long double, nano>{__nsecs}; }
1058 
1059  /// Literal suffix for durations of type `std::chrono::nanoseconds`
1060  template <char... _Digits>
1061  constexpr chrono::nanoseconds
1062  operator""ns()
1063  { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
1064 
1065 #pragma GCC diagnostic pop
1066  } // inline namespace chrono_literals
1067  } // inline namespace literals
1068 
1069  namespace chrono
1070  {
1071  using namespace literals::chrono_literals;
1072  } // namespace chrono
1073 
1074 #endif // C++14
1075 
1076 _GLIBCXX_END_NAMESPACE_VERSION
1077 } // namespace std
1078 
1079 #endif // C++11
1080 
1081 #endif //_GLIBCXX_CHRONO