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