libstdc++
chrono
1 // <chrono> -*- C++ -*-
2 
3 // Copyright (C) 2008-2013 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  */
28 
29 #ifndef _GLIBCXX_CHRONO
30 #define _GLIBCXX_CHRONO 1
31 
32 #pragma GCC system_header
33 
34 #if __cplusplus < 201103L
35 # include <bits/c++0x_warning.h>
36 #else
37 
38 #include <ratio>
39 #include <type_traits>
40 #include <limits>
41 #include <ctime>
42 
43 #ifdef _GLIBCXX_USE_C99_STDINT_TR1
44 
45 namespace std _GLIBCXX_VISIBILITY(default)
46 {
47  /**
48  * @defgroup chrono Time
49  * @ingroup utilities
50  *
51  * Classes and functions for time.
52  * @{
53  */
54 
55  /** @namespace std::chrono
56  * @brief ISO C++ 2011 entities sub-namespace for time and date.
57  */
58  namespace chrono
59  {
60  _GLIBCXX_BEGIN_NAMESPACE_VERSION
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  _GLIBCXX_END_NAMESPACE_VERSION
69  }
70 
71 _GLIBCXX_BEGIN_NAMESPACE_VERSION
72 
73  // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
74 
75  template<typename _CT, typename _Period1, typename _Period2>
76  struct __duration_common_type_wrapper
77  {
78  private:
79  typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num;
80  typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den;
81  typedef typename _CT::type __cr;
82  typedef ratio<__gcd_num::value,
83  (_Period1::den / __gcd_den::value) * _Period2::den> __r;
84  public:
85  typedef __success_type<chrono::duration<__cr, __r>> type;
86  };
87 
88  template<typename _Period1, typename _Period2>
89  struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2>
90  { typedef __failure_type type; };
91 
92  template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
93  struct common_type<chrono::duration<_Rep1, _Period1>,
94  chrono::duration<_Rep2, _Period2>>
95  : public __duration_common_type_wrapper<typename __member_type_wrapper<
96  common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type
97  { };
98 
99  // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
100 
101  template<typename _CT, typename _Clock>
102  struct __timepoint_common_type_wrapper
103  {
104  typedef __success_type<chrono::time_point<_Clock, typename _CT::type>>
105  type;
106  };
107 
108  template<typename _Clock>
109  struct __timepoint_common_type_wrapper<__failure_type, _Clock>
110  { typedef __failure_type type; };
111 
112  template<typename _Clock, typename _Duration1, typename _Duration2>
113  struct common_type<chrono::time_point<_Clock, _Duration1>,
114  chrono::time_point<_Clock, _Duration2>>
115  : public __timepoint_common_type_wrapper<typename __member_type_wrapper<
116  common_type<_Duration1, _Duration2>>::type, _Clock>::type
117  { };
118 
119 _GLIBCXX_END_NAMESPACE_VERSION
120 
121  namespace chrono
122  {
123  _GLIBCXX_BEGIN_NAMESPACE_VERSION
124 
125  // Primary template for duration_cast impl.
126  template<typename _ToDur, typename _CF, typename _CR,
127  bool _NumIsOne = false, bool _DenIsOne = false>
128  struct __duration_cast_impl
129  {
130  template<typename _Rep, typename _Period>
131  static constexpr _ToDur
132  __cast(const duration<_Rep, _Period>& __d)
133  {
134  typedef typename _ToDur::rep __to_rep;
135  return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
136  * static_cast<_CR>(_CF::num)
137  / static_cast<_CR>(_CF::den)));
138  }
139  };
140 
141  template<typename _ToDur, typename _CF, typename _CR>
142  struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
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>(__d.count()));
150  }
151  };
152 
153  template<typename _ToDur, typename _CF, typename _CR>
154  struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
155  {
156  template<typename _Rep, typename _Period>
157  static constexpr _ToDur
158  __cast(const duration<_Rep, _Period>& __d)
159  {
160  typedef typename _ToDur::rep __to_rep;
161  return _ToDur(static_cast<__to_rep>(
162  static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
163  }
164  };
165 
166  template<typename _ToDur, typename _CF, typename _CR>
167  struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
168  {
169  template<typename _Rep, typename _Period>
170  static constexpr _ToDur
171  __cast(const duration<_Rep, _Period>& __d)
172  {
173  typedef typename _ToDur::rep __to_rep;
174  return _ToDur(static_cast<__to_rep>(
175  static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
176  }
177  };
178 
179  template<typename _Tp>
180  struct __is_duration
181  : std::false_type
182  { };
183 
184  template<typename _Rep, typename _Period>
185  struct __is_duration<duration<_Rep, _Period>>
186  : std::true_type
187  { };
188 
189  /// duration_cast
190  template<typename _ToDur, typename _Rep, typename _Period>
191  constexpr typename enable_if<__is_duration<_ToDur>::value,
192  _ToDur>::type
193  duration_cast(const duration<_Rep, _Period>& __d)
194  {
195  typedef typename _ToDur::period __to_period;
196  typedef typename _ToDur::rep __to_rep;
197  typedef ratio_divide<_Period, __to_period> __cf;
198  typedef typename common_type<__to_rep, _Rep, intmax_t>::type
199  __cr;
200  typedef __duration_cast_impl<_ToDur, __cf, __cr,
201  __cf::num == 1, __cf::den == 1> __dc;
202  return __dc::__cast(__d);
203  }
204 
205  /// treat_as_floating_point
206  template<typename _Rep>
207  struct treat_as_floating_point
208  : is_floating_point<_Rep>
209  { };
210 
211  /// duration_values
212  template<typename _Rep>
213  struct duration_values
214  {
215  static constexpr _Rep
216  zero()
217  { return _Rep(0); }
218 
219  static constexpr _Rep
220  max()
221  { return numeric_limits<_Rep>::max(); }
222 
223  static constexpr _Rep
224  min()
225  { return numeric_limits<_Rep>::lowest(); }
226  };
227 
228  template<typename _Tp>
229  struct __is_ratio
230  : std::false_type
231  { };
232 
233  template<intmax_t _Num, intmax_t _Den>
234  struct __is_ratio<ratio<_Num, _Den>>
235  : std::true_type
236  { };
237 
238  /// duration
239  template<typename _Rep, typename _Period>
240  struct duration
241  {
242  typedef _Rep rep;
243  typedef _Period period;
244 
245  static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
246  static_assert(__is_ratio<_Period>::value,
247  "period must be a specialization of ratio");
248  static_assert(_Period::num > 0, "period must be positive");
249 
250  // 20.11.5.1 construction / copy / destroy
251  constexpr duration() = default;
252 
253  // NB: Make constexpr implicit. This cannot be explicitly
254  // constexpr, as any UDT that is not a literal type with a
255  // constexpr copy constructor will be ill-formed.
256  duration(const duration&) = default;
257 
258  template<typename _Rep2, typename = typename
259  enable_if<is_convertible<_Rep2, rep>::value
260  && (treat_as_floating_point<rep>::value
261  || !treat_as_floating_point<_Rep2>::value)>::type>
262  constexpr explicit duration(const _Rep2& __rep)
263  : __r(static_cast<rep>(__rep)) { }
264 
265  template<typename _Rep2, typename _Period2, typename = typename
266  enable_if<treat_as_floating_point<rep>::value
267  || (ratio_divide<_Period2, period>::den == 1
268  && !treat_as_floating_point<_Rep2>::value)>::type>
269  constexpr duration(const duration<_Rep2, _Period2>& __d)
270  : __r(duration_cast<duration>(__d).count()) { }
271 
272  ~duration() = default;
273  duration& operator=(const duration&) = default;
274 
275  // 20.11.5.2 observer
276  constexpr rep
277  count() const
278  { return __r; }
279 
280  // 20.11.5.3 arithmetic
281  constexpr duration
282  operator+() const
283  { return *this; }
284 
285  constexpr duration
286  operator-() const
287  { return duration(-__r); }
288 
289  duration&
290  operator++()
291  {
292  ++__r;
293  return *this;
294  }
295 
296  duration
297  operator++(int)
298  { return duration(__r++); }
299 
300  duration&
301  operator--()
302  {
303  --__r;
304  return *this;
305  }
306 
307  duration
308  operator--(int)
309  { return duration(__r--); }
310 
311  duration&
312  operator+=(const duration& __d)
313  {
314  __r += __d.count();
315  return *this;
316  }
317 
318  duration&
319  operator-=(const duration& __d)
320  {
321  __r -= __d.count();
322  return *this;
323  }
324 
325  duration&
326  operator*=(const rep& __rhs)
327  {
328  __r *= __rhs;
329  return *this;
330  }
331 
332  duration&
333  operator/=(const rep& __rhs)
334  {
335  __r /= __rhs;
336  return *this;
337  }
338 
339  // DR 934.
340  template<typename _Rep2 = rep>
341  typename enable_if<!treat_as_floating_point<_Rep2>::value,
342  duration&>::type
343  operator%=(const rep& __rhs)
344  {
345  __r %= __rhs;
346  return *this;
347  }
348 
349  template<typename _Rep2 = rep>
350  typename enable_if<!treat_as_floating_point<_Rep2>::value,
351  duration&>::type
352  operator%=(const duration& __d)
353  {
354  __r %= __d.count();
355  return *this;
356  }
357 
358  // 20.11.5.4 special values
359  static constexpr duration
360  zero()
361  { return duration(duration_values<rep>::zero()); }
362 
363  static constexpr duration
364  min()
365  { return duration(duration_values<rep>::min()); }
366 
367  static constexpr duration
368  max()
369  { return duration(duration_values<rep>::max()); }
370 
371  private:
372  rep __r;
373  };
374 
375  template<typename _Rep1, typename _Period1,
376  typename _Rep2, typename _Period2>
377  constexpr typename common_type<duration<_Rep1, _Period1>,
378  duration<_Rep2, _Period2>>::type
379  operator+(const duration<_Rep1, _Period1>& __lhs,
380  const duration<_Rep2, _Period2>& __rhs)
381  {
382  typedef duration<_Rep1, _Period1> __dur1;
383  typedef duration<_Rep2, _Period2> __dur2;
384  typedef typename common_type<__dur1,__dur2>::type __cd;
385  return __cd(__cd(__lhs).count() + __cd(__rhs).count());
386  }
387 
388  template<typename _Rep1, typename _Period1,
389  typename _Rep2, typename _Period2>
390  constexpr typename common_type<duration<_Rep1, _Period1>,
391  duration<_Rep2, _Period2>>::type
392  operator-(const duration<_Rep1, _Period1>& __lhs,
393  const duration<_Rep2, _Period2>& __rhs)
394  {
395  typedef duration<_Rep1, _Period1> __dur1;
396  typedef duration<_Rep2, _Period2> __dur2;
397  typedef typename common_type<__dur1,__dur2>::type __cd;
398  return __cd(__cd(__lhs).count() - __cd(__rhs).count());
399  }
400 
401  template<typename _Rep1, typename _Rep2, bool =
402  is_convertible<_Rep2,
403  typename common_type<_Rep1, _Rep2>::type>::value>
404  struct __common_rep_type { };
405 
406  template<typename _Rep1, typename _Rep2>
407  struct __common_rep_type<_Rep1, _Rep2, true>
408  { typedef typename common_type<_Rep1, _Rep2>::type type; };
409 
410  template<typename _Rep1, typename _Period, typename _Rep2>
411  constexpr
412  duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
413  operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
414  {
415  typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
416  __cd;
417  return __cd(__cd(__d).count() * __s);
418  }
419 
420  template<typename _Rep1, typename _Rep2, typename _Period>
421  constexpr
422  duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
423  operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
424  { return __d * __s; }
425 
426  template<typename _Rep1, typename _Period, typename _Rep2>
427  constexpr duration<typename __common_rep_type<_Rep1, typename
428  enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
429  operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
430  {
431  typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
432  __cd;
433  return __cd(__cd(__d).count() / __s);
434  }
435 
436  template<typename _Rep1, typename _Period1,
437  typename _Rep2, typename _Period2>
438  constexpr typename common_type<_Rep1, _Rep2>::type
439  operator/(const duration<_Rep1, _Period1>& __lhs,
440  const duration<_Rep2, _Period2>& __rhs)
441  {
442  typedef duration<_Rep1, _Period1> __dur1;
443  typedef duration<_Rep2, _Period2> __dur2;
444  typedef typename common_type<__dur1,__dur2>::type __cd;
445  return __cd(__lhs).count() / __cd(__rhs).count();
446  }
447 
448  // DR 934.
449  template<typename _Rep1, typename _Period, typename _Rep2>
450  constexpr duration<typename __common_rep_type<_Rep1, typename
451  enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
452  operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
453  {
454  typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
455  __cd;
456  return __cd(__cd(__d).count() % __s);
457  }
458 
459  template<typename _Rep1, typename _Period1,
460  typename _Rep2, typename _Period2>
461  constexpr typename common_type<duration<_Rep1, _Period1>,
462  duration<_Rep2, _Period2>>::type
463  operator%(const duration<_Rep1, _Period1>& __lhs,
464  const duration<_Rep2, _Period2>& __rhs)
465  {
466  typedef duration<_Rep1, _Period1> __dur1;
467  typedef duration<_Rep2, _Period2> __dur2;
468  typedef typename common_type<__dur1,__dur2>::type __cd;
469  return __cd(__cd(__lhs).count() % __cd(__rhs).count());
470  }
471 
472  // comparisons
473  template<typename _Rep1, typename _Period1,
474  typename _Rep2, typename _Period2>
475  constexpr bool
476  operator==(const duration<_Rep1, _Period1>& __lhs,
477  const duration<_Rep2, _Period2>& __rhs)
478  {
479  typedef duration<_Rep1, _Period1> __dur1;
480  typedef duration<_Rep2, _Period2> __dur2;
481  typedef typename common_type<__dur1,__dur2>::type __ct;
482  return __ct(__lhs).count() == __ct(__rhs).count();
483  }
484 
485  template<typename _Rep1, typename _Period1,
486  typename _Rep2, typename _Period2>
487  constexpr bool
488  operator<(const duration<_Rep1, _Period1>& __lhs,
489  const duration<_Rep2, _Period2>& __rhs)
490  {
491  typedef duration<_Rep1, _Period1> __dur1;
492  typedef duration<_Rep2, _Period2> __dur2;
493  typedef typename common_type<__dur1,__dur2>::type __ct;
494  return __ct(__lhs).count() < __ct(__rhs).count();
495  }
496 
497  template<typename _Rep1, typename _Period1,
498  typename _Rep2, typename _Period2>
499  constexpr bool
500  operator!=(const duration<_Rep1, _Period1>& __lhs,
501  const duration<_Rep2, _Period2>& __rhs)
502  { return !(__lhs == __rhs); }
503 
504  template<typename _Rep1, typename _Period1,
505  typename _Rep2, typename _Period2>
506  constexpr bool
507  operator<=(const duration<_Rep1, _Period1>& __lhs,
508  const duration<_Rep2, _Period2>& __rhs)
509  { return !(__rhs < __lhs); }
510 
511  template<typename _Rep1, typename _Period1,
512  typename _Rep2, typename _Period2>
513  constexpr bool
514  operator>(const duration<_Rep1, _Period1>& __lhs,
515  const duration<_Rep2, _Period2>& __rhs)
516  { return __rhs < __lhs; }
517 
518  template<typename _Rep1, typename _Period1,
519  typename _Rep2, typename _Period2>
520  constexpr bool
521  operator>=(const duration<_Rep1, _Period1>& __lhs,
522  const duration<_Rep2, _Period2>& __rhs)
523  { return !(__lhs < __rhs); }
524 
525  /// nanoseconds
526  typedef duration<int64_t, nano> nanoseconds;
527 
528  /// microseconds
529  typedef duration<int64_t, micro> microseconds;
530 
531  /// milliseconds
532  typedef duration<int64_t, milli> milliseconds;
533 
534  /// seconds
535  typedef duration<int64_t> seconds;
536 
537  /// minutes
538  typedef duration<int, ratio< 60>> minutes;
539 
540  /// hours
541  typedef duration<int, ratio<3600>> hours;
542 
543  /// time_point
544  template<typename _Clock, typename _Dur>
545  struct time_point
546  {
547  typedef _Clock clock;
548  typedef _Dur duration;
549  typedef typename duration::rep rep;
550  typedef typename duration::period period;
551 
552  constexpr time_point() : __d(duration::zero())
553  { }
554 
555  constexpr explicit time_point(const duration& __dur)
556  : __d(__dur)
557  { }
558 
559  // conversions
560  template<typename _Dur2>
561  constexpr time_point(const time_point<clock, _Dur2>& __t)
562  : __d(__t.time_since_epoch())
563  { }
564 
565  // observer
566  constexpr duration
567  time_since_epoch() const
568  { return __d; }
569 
570  // arithmetic
571  time_point&
572  operator+=(const duration& __dur)
573  {
574  __d += __dur;
575  return *this;
576  }
577 
578  time_point&
579  operator-=(const duration& __dur)
580  {
581  __d -= __dur;
582  return *this;
583  }
584 
585  // special values
586  static constexpr time_point
587  min()
588  { return time_point(duration::min()); }
589 
590  static constexpr time_point
591  max()
592  { return time_point(duration::max()); }
593 
594  private:
595  duration __d;
596  };
597 
598  /// time_point_cast
599  template<typename _ToDur, typename _Clock, typename _Dur>
600  constexpr typename enable_if<__is_duration<_ToDur>::value,
601  time_point<_Clock, _ToDur>>::type
602  time_point_cast(const time_point<_Clock, _Dur>& __t)
603  {
604  typedef time_point<_Clock, _ToDur> __time_point;
605  return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
606  }
607 
608  template<typename _Clock, typename _Dur1,
609  typename _Rep2, typename _Period2>
610  constexpr time_point<_Clock,
611  typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
612  operator+(const time_point<_Clock, _Dur1>& __lhs,
613  const duration<_Rep2, _Period2>& __rhs)
614  {
615  typedef duration<_Rep2, _Period2> __dur2;
616  typedef typename common_type<_Dur1,__dur2>::type __ct;
617  typedef time_point<_Clock, __ct> __time_point;
618  return __time_point(__lhs.time_since_epoch() + __rhs);
619  }
620 
621  template<typename _Rep1, typename _Period1,
622  typename _Clock, typename _Dur2>
623  constexpr time_point<_Clock,
624  typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
625  operator+(const duration<_Rep1, _Period1>& __lhs,
626  const time_point<_Clock, _Dur2>& __rhs)
627  {
628  typedef duration<_Rep1, _Period1> __dur1;
629  typedef typename common_type<__dur1,_Dur2>::type __ct;
630  typedef time_point<_Clock, __ct> __time_point;
631  return __time_point(__rhs.time_since_epoch() + __lhs);
632  }
633 
634  template<typename _Clock, typename _Dur1,
635  typename _Rep2, typename _Period2>
636  constexpr time_point<_Clock,
637  typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
638  operator-(const time_point<_Clock, _Dur1>& __lhs,
639  const duration<_Rep2, _Period2>& __rhs)
640  {
641  typedef duration<_Rep2, _Period2> __dur2;
642  typedef typename common_type<_Dur1,__dur2>::type __ct;
643  typedef time_point<_Clock, __ct> __time_point;
644  return __time_point(__lhs.time_since_epoch() -__rhs);
645  }
646 
647  template<typename _Clock, typename _Dur1, typename _Dur2>
648  constexpr typename common_type<_Dur1, _Dur2>::type
649  operator-(const time_point<_Clock, _Dur1>& __lhs,
650  const time_point<_Clock, _Dur2>& __rhs)
651  { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
652 
653  template<typename _Clock, typename _Dur1, typename _Dur2>
654  constexpr bool
655  operator==(const time_point<_Clock, _Dur1>& __lhs,
656  const time_point<_Clock, _Dur2>& __rhs)
657  { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
658 
659  template<typename _Clock, typename _Dur1, typename _Dur2>
660  constexpr bool
661  operator!=(const time_point<_Clock, _Dur1>& __lhs,
662  const time_point<_Clock, _Dur2>& __rhs)
663  { return !(__lhs == __rhs); }
664 
665  template<typename _Clock, typename _Dur1, typename _Dur2>
666  constexpr bool
667  operator<(const time_point<_Clock, _Dur1>& __lhs,
668  const time_point<_Clock, _Dur2>& __rhs)
669  { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
670 
671  template<typename _Clock, typename _Dur1, typename _Dur2>
672  constexpr bool
673  operator<=(const time_point<_Clock, _Dur1>& __lhs,
674  const time_point<_Clock, _Dur2>& __rhs)
675  { return !(__rhs < __lhs); }
676 
677  template<typename _Clock, typename _Dur1, typename _Dur2>
678  constexpr bool
679  operator>(const time_point<_Clock, _Dur1>& __lhs,
680  const time_point<_Clock, _Dur2>& __rhs)
681  { return __rhs < __lhs; }
682 
683  template<typename _Clock, typename _Dur1, typename _Dur2>
684  constexpr bool
685  operator>=(const time_point<_Clock, _Dur1>& __lhs,
686  const time_point<_Clock, _Dur2>& __rhs)
687  { return !(__lhs < __rhs); }
688 
689 
690  // Clocks.
691 
692  // Why nanosecond resolution as the default?
693  // Why have std::system_clock always count in the higest
694  // resolution (ie nanoseconds), even if on some OSes the low 3
695  // or 9 decimal digits will be always zero? This allows later
696  // implementations to change the system_clock::now()
697  // implementation any time to provide better resolution without
698  // changing function signature or units.
699 
700  // To support the (forward) evolution of the library's defined
701  // clocks, wrap inside inline namespace so that the current
702  // defintions of system_clock, steady_clock, and
703  // high_resolution_clock types are uniquely mangled. This way, new
704  // code can use the latests clocks, while the library can contain
705  // compatibility definitions for previous versions. At some
706  // point, when these clocks settle down, the inlined namespaces
707  // can be removed. XXX GLIBCXX_ABI Deprecated
708  inline namespace _V2 {
709 
710  /**
711  * @brief System clock.
712  *
713  * Time returned represents wall time from the system-wide clock.
714  */
715  struct system_clock
716  {
717  typedef chrono::nanoseconds duration;
718  typedef duration::rep rep;
719  typedef duration::period period;
720  typedef chrono::time_point<system_clock, duration> time_point;
721 
722  static_assert(system_clock::duration::min()
723  < system_clock::duration::zero(),
724  "a clock's minimum duration cannot be less than its epoch");
725 
726  static constexpr bool is_steady = false;
727 
728  static time_point
729  now() noexcept;
730 
731  // Map to C API
732  static std::time_t
733  to_time_t(const time_point& __t) noexcept
734  {
735  return std::time_t(duration_cast<chrono::seconds>
736  (__t.time_since_epoch()).count());
737  }
738 
739  static time_point
740  from_time_t(std::time_t __t) noexcept
741  {
742  typedef chrono::time_point<system_clock, seconds> __from;
743  return time_point_cast<system_clock::duration>
744  (__from(chrono::seconds(__t)));
745  }
746  };
747 
748 
749  /**
750  * @brief Monotonic clock
751  *
752  * Time returned has the property of only increasing at a uniform rate.
753  */
754  struct steady_clock
755  {
756  typedef chrono::nanoseconds duration;
757  typedef duration::rep rep;
758  typedef duration::period period;
759  typedef chrono::time_point<steady_clock, duration> time_point;
760 
761  static constexpr bool is_steady = true;
762 
763  static time_point
764  now() noexcept;
765  };
766 
767 
768  /**
769  * @brief Highest-resolution clock
770  *
771  * This is the clock "with the shortest tick period." Alias to
772  * std::system_clock until higher-than-nanosecond definitions
773  * become feasible.
774  */
775  using high_resolution_clock = system_clock;
776 
777  } // end inline namespace _V2
778 
779  _GLIBCXX_END_NAMESPACE_VERSION
780  } // namespace chrono
781 
782  // @} group chrono
783 } // namespace
784 
785 #endif //_GLIBCXX_USE_C99_STDINT_TR1
786 
787 #endif // C++11
788 
789 #endif //_GLIBCXX_CHRONO