l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.8/include/std/chrono

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