contrib/gcc-8.0/libstdc++-v3/include/std/chrono

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