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

   1 // <chrono> -*- C++ -*-
   2
   3 // Copyright (C) 2008-2015 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   /**
  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     /// duration_values
 213     template<typename _Rep>
 214       struct duration_values
 215       {
 216         static constexpr _Rep
 217         zero()
 218         { return _Rep(0); }
 219
 220         static constexpr _Rep
 221         max()
 222         { return numeric_limits<_Rep>::max(); }
 223
 224         static constexpr _Rep
 225         min()
 226         { return numeric_limits<_Rep>::lowest(); }
 227       };
 228
 229     template<typename _Tp>
 230       struct __is_ratio
 231       : std::false_type
 232       { };
 233
 234     template<intmax_t _Num, intmax_t _Den>
 235       struct __is_ratio<ratio<_Num, _Den>>
 236       : std::true_type
 237       { };
 238
 239     /// duration
 240     template<typename _Rep, typename _Period>
 241       struct duration
 242       {
 243         typedef _Rep                                            rep;
 244         typedef _Period                                         period;
 245
 246         static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
 247         static_assert(__is_ratio<_Period>::value,
 248                       "period must be a specialization of ratio");
 249         static_assert(_Period::num > 0, "period must be positive");
 250
 251         // 20.11.5.1 construction / copy / destroy
 252         constexpr duration() = default;
 253
 254         // NB: Make constexpr implicit. This cannot be explicitly
 255         // constexpr, as any UDT that is not a literal type with a
 256         // constexpr copy constructor will be ill-formed.
 257         duration(const duration&) = default;
 258
 259         template<typename _Rep2, typename = typename
 260                enable_if<is_convertible<_Rep2, rep>::value
 261                          && (treat_as_floating_point<rep>::value
 262                              || !treat_as_floating_point<_Rep2>::value)>::type>
 263           constexpr explicit duration(const _Rep2& __rep)
 264           : __r(static_cast<rep>(__rep)) { }
 265
 266         template<typename _Rep2, typename _Period2, typename = typename
 267                enable_if<treat_as_floating_point<rep>::value
 268                          || (ratio_divide<_Period2, period>::den == 1
 269                              && !treat_as_floating_point<_Rep2>::value)>::type>
 270           constexpr duration(const duration<_Rep2, _Period2>& __d)
 271           : __r(duration_cast<duration>(__d).count()) { }
 272
 273         ~duration() = default;
 274         duration& operator=(const duration&) = default;
 275
 276         // 20.11.5.2 observer
 277         constexpr rep
 278         count() const
 279         { return __r; }
 280
 281         // 20.11.5.3 arithmetic
 282         constexpr duration
 283         operator+() const
 284         { return *this; }
 285
 286         constexpr duration
 287         operator-() const
 288         { return duration(-__r); }
 289
 290         duration&
 291         operator++()
 292         {
 293           ++__r;
 294           return *this;
 295         }
 296
 297         duration
 298         operator++(int)
 299         { return duration(__r++); }
 300
 301         duration&
 302         operator--()
 303         {
 304           --__r;
 305           return *this;
 306         }
 307
 308         duration
 309         operator--(int)
 310         { return duration(__r--); }
 311
 312         duration&
 313         operator+=(const duration& __d)
 314         {
 315           __r += __d.count();
 316           return *this;
 317         }
 318
 319         duration&
 320         operator-=(const duration& __d)
 321         {
 322           __r -= __d.count();
 323           return *this;
 324         }
 325
 326         duration&
 327         operator*=(const rep& __rhs)
 328         {
 329           __r *= __rhs;
 330           return *this;
 331         }
 332
 333         duration&
 334         operator/=(const rep& __rhs)
 335         {
 336           __r /= __rhs;
 337           return *this;
 338         }
 339
 340         // DR 934.
 341         template<typename _Rep2 = rep>
 342           typename enable_if<!treat_as_floating_point<_Rep2>::value,
 343                              duration&>::type
 344           operator%=(const rep& __rhs)
 345           {
 346             __r %= __rhs;
 347             return *this;
 348           }
 349
 350         template<typename _Rep2 = rep>
 351           typename enable_if<!treat_as_floating_point<_Rep2>::value,
 352                              duration&>::type
 353           operator%=(const duration& __d)
 354           {
 355             __r %= __d.count();
 356             return *this;
 357           }
 358
 359         // 20.11.5.4 special values
 360         static constexpr duration
 361         zero()
 362         { return duration(duration_values<rep>::zero()); }
 363
 364         static constexpr duration
 365         min()
 366         { return duration(duration_values<rep>::min()); }
 367
 368         static constexpr duration
 369         max()
 370         { return duration(duration_values<rep>::max()); }
 371
 372       private:
 373         rep __r;
 374       };
 375
 376     template<typename _Rep1, typename _Period1,
 377              typename _Rep2, typename _Period2>
 378       constexpr typename common_type<duration<_Rep1, _Period1>,
 379                                      duration<_Rep2, _Period2>>::type
 380       operator+(const duration<_Rep1, _Period1>& __lhs,
 381                 const duration<_Rep2, _Period2>& __rhs)
 382       {
 383         typedef duration<_Rep1, _Period1>                       __dur1;
 384         typedef duration<_Rep2, _Period2>                       __dur2;
 385         typedef typename common_type<__dur1,__dur2>::type       __cd;
 386         return __cd(__cd(__lhs).count() + __cd(__rhs).count());
 387       }
 388
 389     template<typename _Rep1, typename _Period1,
 390              typename _Rep2, typename _Period2>
 391       constexpr typename common_type<duration<_Rep1, _Period1>,
 392                                      duration<_Rep2, _Period2>>::type
 393       operator-(const duration<_Rep1, _Period1>& __lhs,
 394                 const duration<_Rep2, _Period2>& __rhs)
 395       {
 396         typedef duration<_Rep1, _Period1>                       __dur1;
 397         typedef duration<_Rep2, _Period2>                       __dur2;
 398         typedef typename common_type<__dur1,__dur2>::type       __cd;
 399         return __cd(__cd(__lhs).count() - __cd(__rhs).count());
 400       }
 401
 402     template<typename _Rep1, typename _Rep2, bool =
 403              is_convertible<_Rep2,
 404                             typename common_type<_Rep1, _Rep2>::type>::value>
 405       struct __common_rep_type { };
 406
 407     template<typename _Rep1, typename _Rep2>
 408       struct __common_rep_type<_Rep1, _Rep2, true>
 409       { typedef typename common_type<_Rep1, _Rep2>::type type; };
 410
 411     template<typename _Rep1, typename _Period, typename _Rep2>
 412       constexpr
 413       duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
 414       operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 415       {
 416         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 417           __cd;
 418         return __cd(__cd(__d).count() * __s);
 419       }
 420
 421     template<typename _Rep1, typename _Rep2, typename _Period>
 422       constexpr
 423       duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
 424       operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
 425       { return __d * __s; }
 426
 427     template<typename _Rep1, typename _Period, typename _Rep2>
 428       constexpr duration<typename __common_rep_type<_Rep1, typename
 429         enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
 430       operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 431       {
 432         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 433           __cd;
 434         return __cd(__cd(__d).count() / __s);
 435       }
 436
 437     template<typename _Rep1, typename _Period1,
 438              typename _Rep2, typename _Period2>
 439       constexpr typename common_type<_Rep1, _Rep2>::type
 440       operator/(const duration<_Rep1, _Period1>& __lhs,
 441                 const duration<_Rep2, _Period2>& __rhs)
 442       {
 443         typedef duration<_Rep1, _Period1>                       __dur1;
 444         typedef duration<_Rep2, _Period2>                       __dur2;
 445         typedef typename common_type<__dur1,__dur2>::type       __cd;
 446         return __cd(__lhs).count() / __cd(__rhs).count();
 447       }
 448
 449     // DR 934.
 450     template<typename _Rep1, typename _Period, typename _Rep2>
 451       constexpr duration<typename __common_rep_type<_Rep1, typename
 452         enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
 453       operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 454       {
 455         typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 456           __cd;
 457         return __cd(__cd(__d).count() % __s);
 458       }
 459
 460     template<typename _Rep1, typename _Period1,
 461              typename _Rep2, typename _Period2>
 462       constexpr typename common_type<duration<_Rep1, _Period1>,
 463                                      duration<_Rep2, _Period2>>::type
 464       operator%(const duration<_Rep1, _Period1>& __lhs,
 465                 const duration<_Rep2, _Period2>& __rhs)
 466       {
 467         typedef duration<_Rep1, _Period1>                       __dur1;
 468         typedef duration<_Rep2, _Period2>                       __dur2;
 469         typedef typename common_type<__dur1,__dur2>::type       __cd;
 470         return __cd(__cd(__lhs).count() % __cd(__rhs).count());
 471       }
 472
 473     // comparisons
 474     template<typename _Rep1, typename _Period1,
 475              typename _Rep2, typename _Period2>
 476       constexpr bool
 477       operator==(const duration<_Rep1, _Period1>& __lhs,
 478                  const duration<_Rep2, _Period2>& __rhs)
 479       {
 480         typedef duration<_Rep1, _Period1>                       __dur1;
 481         typedef duration<_Rep2, _Period2>                       __dur2;
 482         typedef typename common_type<__dur1,__dur2>::type       __ct;
 483         return __ct(__lhs).count() == __ct(__rhs).count();
 484       }
 485
 486     template<typename _Rep1, typename _Period1,
 487              typename _Rep2, typename _Period2>
 488       constexpr bool
 489       operator<(const duration<_Rep1, _Period1>& __lhs,
 490                 const duration<_Rep2, _Period2>& __rhs)
 491       {
 492         typedef duration<_Rep1, _Period1>                       __dur1;
 493         typedef duration<_Rep2, _Period2>                       __dur2;
 494         typedef typename common_type<__dur1,__dur2>::type       __ct;
 495         return __ct(__lhs).count() < __ct(__rhs).count();
 496       }
 497
 498     template<typename _Rep1, typename _Period1,
 499              typename _Rep2, typename _Period2>
 500       constexpr bool
 501       operator!=(const duration<_Rep1, _Period1>& __lhs,
 502                  const duration<_Rep2, _Period2>& __rhs)
 503       { return !(__lhs == __rhs); }
 504
 505     template<typename _Rep1, typename _Period1,
 506              typename _Rep2, typename _Period2>
 507       constexpr bool
 508       operator<=(const duration<_Rep1, _Period1>& __lhs,
 509                  const duration<_Rep2, _Period2>& __rhs)
 510       { return !(__rhs < __lhs); }
 511
 512     template<typename _Rep1, typename _Period1,
 513              typename _Rep2, typename _Period2>
 514       constexpr bool
 515       operator>(const duration<_Rep1, _Period1>& __lhs,
 516                 const duration<_Rep2, _Period2>& __rhs)
 517       { return __rhs < __lhs; }
 518
 519     template<typename _Rep1, typename _Period1,
 520              typename _Rep2, typename _Period2>
 521       constexpr bool
 522       operator>=(const duration<_Rep1, _Period1>& __lhs,
 523                  const duration<_Rep2, _Period2>& __rhs)
 524       { return !(__lhs < __rhs); }
 525
 526     /// nanoseconds
 527     typedef duration<int64_t, nano>         nanoseconds;
 528
 529     /// microseconds
 530     typedef duration<int64_t, micro>        microseconds;
 531
 532     /// milliseconds
 533     typedef duration<int64_t, milli>        milliseconds;
 534
 535     /// seconds
 536     typedef duration<int64_t>               seconds;
 537
 538     /// minutes
 539     typedef duration<int64_t, ratio< 60>>   minutes;
 540
 541     /// hours
 542     typedef duration<int64_t, ratio<3600>>  hours;
 543
 544     /// time_point
 545     template<typename _Clock, typename _Dur>
 546       struct time_point
 547       {
 548         typedef _Clock                                          clock;
 549         typedef _Dur                                            duration;
 550         typedef typename duration::rep                          rep;
 551         typedef typename duration::period                       period;
 552
 553         constexpr time_point() : __d(duration::zero())
 554         { }
 555
 556         constexpr explicit time_point(const duration& __dur)
 557         : __d(__dur)
 558         { }
 559
 560         // conversions
 561         template<typename _Dur2>
 562           constexpr time_point(const time_point<clock, _Dur2>& __t)
 563           : __d(__t.time_since_epoch())
 564           { }
 565
 566         // observer
 567         constexpr duration
 568         time_since_epoch() const
 569         { return __d; }
 570
 571         // arithmetic
 572         time_point&
 573         operator+=(const duration& __dur)
 574         {
 575           __d += __dur;
 576           return *this;
 577         }
 578
 579         time_point&
 580         operator-=(const duration& __dur)
 581         {
 582           __d -= __dur;
 583           return *this;
 584         }
 585
 586         // special values
 587         static constexpr time_point
 588         min()
 589         { return time_point(duration::min()); }
 590
 591         static constexpr time_point
 592         max()
 593         { return time_point(duration::max()); }
 594
 595       private:
 596         duration __d;
 597       };
 598
 599     /// time_point_cast
 600     template<typename _ToDur, typename _Clock, typename _Dur>
 601       constexpr typename enable_if<__is_duration<_ToDur>::value,
 602                                    time_point<_Clock, _ToDur>>::type
 603       time_point_cast(const time_point<_Clock, _Dur>& __t)
 604       {
 605         typedef time_point<_Clock, _ToDur>                      __time_point;
 606         return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
 607       }
 608
 609     template<typename _Clock, typename _Dur1,
 610              typename _Rep2, typename _Period2>
 611       constexpr time_point<_Clock,
 612         typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
 613       operator+(const time_point<_Clock, _Dur1>& __lhs,
 614                 const duration<_Rep2, _Period2>& __rhs)
 615       {
 616         typedef duration<_Rep2, _Period2>                       __dur2;
 617         typedef typename common_type<_Dur1,__dur2>::type        __ct;
 618         typedef time_point<_Clock, __ct>                        __time_point;
 619         return __time_point(__lhs.time_since_epoch() + __rhs);
 620       }
 621
 622     template<typename _Rep1, typename _Period1,
 623              typename _Clock, typename _Dur2>
 624       constexpr time_point<_Clock,
 625         typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
 626       operator+(const duration<_Rep1, _Period1>& __lhs,
 627                 const time_point<_Clock, _Dur2>& __rhs)
 628       {
 629         typedef duration<_Rep1, _Period1>                       __dur1;
 630         typedef typename common_type<__dur1,_Dur2>::type        __ct;
 631         typedef time_point<_Clock, __ct>                        __time_point;
 632         return __time_point(__rhs.time_since_epoch() + __lhs);
 633       }
 634
 635     template<typename _Clock, typename _Dur1,
 636              typename _Rep2, typename _Period2>
 637       constexpr time_point<_Clock,
 638         typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
 639       operator-(const time_point<_Clock, _Dur1>& __lhs,
 640                 const duration<_Rep2, _Period2>& __rhs)
 641       {
 642         typedef duration<_Rep2, _Period2>                       __dur2;
 643         typedef typename common_type<_Dur1,__dur2>::type        __ct;
 644         typedef time_point<_Clock, __ct>                        __time_point;
 645         return __time_point(__lhs.time_since_epoch() -__rhs);
 646       }
 647
 648     template<typename _Clock, typename _Dur1, typename _Dur2>
 649       constexpr typename common_type<_Dur1, _Dur2>::type
 650       operator-(const time_point<_Clock, _Dur1>& __lhs,
 651                 const time_point<_Clock, _Dur2>& __rhs)
 652       { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
 653
 654     template<typename _Clock, typename _Dur1, typename _Dur2>
 655       constexpr bool
 656       operator==(const time_point<_Clock, _Dur1>& __lhs,
 657                  const time_point<_Clock, _Dur2>& __rhs)
 658       { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
 659
 660     template<typename _Clock, typename _Dur1, typename _Dur2>
 661       constexpr bool
 662       operator!=(const time_point<_Clock, _Dur1>& __lhs,
 663                  const time_point<_Clock, _Dur2>& __rhs)
 664       { return !(__lhs == __rhs); }
 665
 666     template<typename _Clock, typename _Dur1, typename _Dur2>
 667       constexpr bool
 668       operator<(const time_point<_Clock, _Dur1>& __lhs,
 669                 const time_point<_Clock, _Dur2>& __rhs)
 670       { return  __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
 671
 672     template<typename _Clock, typename _Dur1, typename _Dur2>
 673       constexpr bool
 674       operator<=(const time_point<_Clock, _Dur1>& __lhs,
 675                  const time_point<_Clock, _Dur2>& __rhs)
 676       { return !(__rhs < __lhs); }
 677
 678     template<typename _Clock, typename _Dur1, typename _Dur2>
 679       constexpr bool
 680       operator>(const time_point<_Clock, _Dur1>& __lhs,
 681                 const time_point<_Clock, _Dur2>& __rhs)
 682       { return __rhs < __lhs; }
 683
 684     template<typename _Clock, typename _Dur1, typename _Dur2>
 685       constexpr bool
 686       operator>=(const time_point<_Clock, _Dur1>& __lhs,
 687                  const time_point<_Clock, _Dur2>& __rhs)
 688       { return !(__lhs < __rhs); }
 689
 690
 691     // Clocks.
 692
 693     // Why nanosecond resolution as the default?
 694     // Why have std::system_clock always count in the higest
 695     // resolution (ie nanoseconds), even if on some OSes the low 3
 696     // or 9 decimal digits will be always zero? This allows later
 697     // implementations to change the system_clock::now()
 698     // implementation any time to provide better resolution without
 699     // changing function signature or units.
 700
 701     // To support the (forward) evolution of the library's defined
 702     // clocks, wrap inside inline namespace so that the current
 703     // defintions of system_clock, steady_clock, and
 704     // high_resolution_clock types are uniquely mangled. This way, new
 705     // code can use the latests clocks, while the library can contain
 706     // compatibility definitions for previous versions.  At some
 707     // point, when these clocks settle down, the inlined namespaces
 708     // can be removed.  XXX GLIBCXX_ABI Deprecated
 709     inline namespace _V2 {
 710
 711     /**
 712      *  @brief System clock.
 713      *
 714      *  Time returned represents wall time from the system-wide clock.
 715     */
 716     struct system_clock
 717     {
 718       typedef chrono::nanoseconds                               duration;
 719       typedef duration::rep                                     rep;
 720       typedef duration::period                                  period;
 721       typedef chrono::time_point<system_clock, duration>        time_point;
 722
 723       static_assert(system_clock::duration::min()
 724                     < system_clock::duration::zero(),
 725                     "a clock's minimum duration cannot be less than its epoch");
 726
 727       static constexpr bool is_steady = false;
 728
 729       static time_point
 730       now() noexcept;
 731
 732       // Map to C API
 733       static std::time_t
 734       to_time_t(const time_point& __t) noexcept
 735       {
 736         return std::time_t(duration_cast<chrono::seconds>
 737                            (__t.time_since_epoch()).count());
 738       }
 739
 740       static time_point
 741       from_time_t(std::time_t __t) noexcept
 742       {
 743         typedef chrono::time_point<system_clock, seconds>       __from;
 744         return time_point_cast<system_clock::duration>
 745                (__from(chrono::seconds(__t)));
 746       }
 747     };
 748
 749
 750     /**
 751      *  @brief Monotonic clock
 752      *
 753      *  Time returned has the property of only increasing at a uniform rate.
 754     */
 755     struct steady_clock
 756     {
 757       typedef chrono::nanoseconds                               duration;
 758       typedef duration::rep                                     rep;
 759       typedef duration::period                                  period;
 760       typedef chrono::time_point<steady_clock, duration>        time_point;
 761
 762       static constexpr bool is_steady = true;
 763
 764       static time_point
 765       now() noexcept;
 766     };
 767
 768
 769     /**
 770      *  @brief Highest-resolution clock
 771      *
 772      *  This is the clock "with the shortest tick period." Alias to
 773      *  std::system_clock until higher-than-nanosecond definitions
 774      *  become feasible.
 775     */
 776     using high_resolution_clock = system_clock;
 777
 778     } // end inline namespace _V2
 779
 780   _GLIBCXX_END_NAMESPACE_VERSION
 781   } // namespace chrono
 782
 783 #if __cplusplus > 201103L
 784
 785 #define __cpp_lib_chrono_udls 201304
 786
 787   inline namespace literals
 788   {
 789   inline namespace chrono_literals
 790   {
 791
 792     template<typename _Rep, unsigned long long _Val>
 793       struct _Checked_integral_constant
 794       : integral_constant<_Rep, static_cast<_Rep>(_Val)>
 795       {
 796         static_assert(_Checked_integral_constant::value >= 0
 797                       && _Checked_integral_constant::value == _Val,
 798                       "literal value cannot be represented by duration type");
 799       };
 800
 801     template<typename _Dur, char... _Digits>
 802       constexpr _Dur __check_overflow()
 803       {
 804         using _Val = __parse_int::_Parse_int<_Digits...>;
 805         using _Rep = typename _Dur::rep;
 806         // TODO: should be simply integral_constant<_Rep, _Val::value>
 807         // but GCC doesn't reject narrowing conversions to _Rep.
 808         using _CheckedVal = _Checked_integral_constant<_Rep, _Val::value>;
 809         return _Dur{_CheckedVal::value};
 810       }
 811
 812     constexpr chrono::duration<long double, ratio<3600,1>>
 813     operator""h(long double __hours)
 814     { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
 815
 816     template <char... _Digits>
 817       constexpr chrono::hours
 818       operator""h()
 819       { return __check_overflow<chrono::hours, _Digits...>(); }
 820
 821     constexpr chrono::duration<long double, ratio<60,1>>
 822     operator""min(long double __mins)
 823     { return chrono::duration<long double, ratio<60,1>>{__mins}; }
 824
 825     template <char... _Digits>
 826       constexpr chrono::minutes
 827       operator""min()
 828       { return __check_overflow<chrono::minutes, _Digits...>(); }
 829
 830     constexpr chrono::duration<long double>
 831     operator""s(long double __secs)
 832     { return chrono::duration<long double>{__secs}; }
 833
 834     template <char... _Digits>
 835       constexpr chrono::seconds
 836       operator""s()
 837       { return __check_overflow<chrono::seconds, _Digits...>(); }
 838
 839     constexpr chrono::duration<long double, milli>
 840     operator""ms(long double __msecs)
 841     { return chrono::duration<long double, milli>{__msecs}; }
 842
 843     template <char... _Digits>
 844       constexpr chrono::milliseconds
 845       operator""ms()
 846       { return __check_overflow<chrono::milliseconds, _Digits...>(); }
 847
 848     constexpr chrono::duration<long double, micro>
 849     operator""us(long double __usecs)
 850     { return chrono::duration<long double, micro>{__usecs}; }
 851
 852     template <char... _Digits>
 853       constexpr chrono::microseconds
 854       operator""us()
 855       { return __check_overflow<chrono::microseconds, _Digits...>(); }
 856
 857     constexpr chrono::duration<long double, nano>
 858     operator""ns(long double __nsecs)
 859     { return chrono::duration<long double, nano>{__nsecs}; }
 860
 861     template <char... _Digits>
 862       constexpr chrono::nanoseconds
 863       operator""ns()
 864       { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
 865
 866   } // inline namespace chrono_literals
 867   } // inline namespace literals
 868
 869   namespace chrono
 870   {
 871   _GLIBCXX_BEGIN_NAMESPACE_VERSION
 872
 873   using namespace literals::chrono_literals;
 874
 875   _GLIBCXX_END_NAMESPACE_VERSION
 876   } // namespace chrono
 877
 878 #endif // __cplusplus > 201103L
 879
 880   // @} group chrono
 881 } // namespace std
 882
 883 #endif //_GLIBCXX_USE_C99_STDINT_TR1
 884
 885 #endif // C++11
 886
 887 #endif //_GLIBCXX_CHRONO