contrib/libc++/include/chrono

   1 // -*- C++ -*-
   2 //===---------------------------- chrono ----------------------------------===//
   3 //
   4 //                     The LLVM Compiler Infrastructure
   5 //
   6 // This file is dual licensed under the MIT and the University of Illinois Open
   7 // Source Licenses. See LICENSE.TXT for details.
   8 //
   9 //===----------------------------------------------------------------------===//
  10
  11 #ifndef _LIBCPP_CHRONO
  12 #define _LIBCPP_CHRONO
  13
  14 /*
  15     chrono synopsis
  16
  17 namespace std
  18 {
  19 namespace chrono
  20 {
  21
  22 template <class ToDuration, class Rep, class Period>
  23 constexpr
  24 ToDuration
  25 duration_cast(const duration<Rep, Period>& fd);
  26
  27 template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {};
  28
  29 template <class Rep> constexpr bool treat_as_floating_point_v
  30     = treat_as_floating_point<Rep>::value;                       // C++17
  31
  32 template <class Rep>
  33 struct duration_values
  34 {
  35 public:
  36     static constexpr Rep zero();
  37     static constexpr Rep max();
  38     static constexpr Rep min();
  39 };
  40
  41 // duration
  42
  43 template <class Rep, class Period = ratio<1>>
  44 class duration
  45 {
  46     static_assert(!__is_duration<Rep>::value, "A duration representation can not be a duration");
  47     static_assert(__is_ratio<Period>::value, "Second template parameter of duration must be a std::ratio");
  48     static_assert(Period::num > 0, "duration period must be positive");
  49 public:
  50     typedef Rep rep;
  51     typedef typename _Period::type period;
  52
  53     constexpr duration() = default;
  54     template <class Rep2>
  55         constexpr explicit duration(const Rep2& r,
  56             typename enable_if
  57             <
  58                is_convertible<Rep2, rep>::value &&
  59                (treat_as_floating_point<rep>::value ||
  60                !treat_as_floating_point<rep>::value && !treat_as_floating_point<Rep2>::value)
  61             >::type* = 0);
  62
  63     // conversions
  64     template <class Rep2, class Period2>
  65         constexpr duration(const duration<Rep2, Period2>& d,
  66             typename enable_if
  67             <
  68                 treat_as_floating_point<rep>::value ||
  69                 ratio_divide<Period2, period>::type::den == 1
  70             >::type* = 0);
  71
  72     // observer
  73
  74     constexpr rep count() const;
  75
  76     // arithmetic
  77
  78     constexpr common_type<duration>::type  operator+() const;
  79     constexpr common_type<duration>::type  operator-() const;
  80     constexpr duration& operator++();
  81     constexpr duration  operator++(int);
  82     constexpr duration& operator--();
  83     constexpr duration  operator--(int);
  84
  85     constexpr duration& operator+=(const duration& d);
  86     constexpr duration& operator-=(const duration& d);
  87
  88     duration& operator*=(const rep& rhs);
  89     duration& operator/=(const rep& rhs);
  90
  91     // special values
  92
  93     static constexpr duration zero();
  94     static constexpr duration min();
  95     static constexpr duration max();
  96 };
  97
  98 typedef duration<long long,         nano> nanoseconds;
  99 typedef duration<long long,        micro> microseconds;
 100 typedef duration<long long,        milli> milliseconds;
 101 typedef duration<long long              > seconds;
 102 typedef duration<     long, ratio<  60> > minutes;
 103 typedef duration<     long, ratio<3600> > hours;
 104
 105 template <class Clock, class Duration = typename Clock::duration>
 106 class time_point
 107 {
 108 public:
 109     typedef Clock                     clock;
 110     typedef Duration                  duration;
 111     typedef typename duration::rep    rep;
 112     typedef typename duration::period period;
 113 private:
 114     duration d_;  // exposition only
 115
 116 public:
 117     time_point();  // has value "epoch" // constexpr in C++14
 118     explicit time_point(const duration& d);  // same as time_point() + d // constexpr in C++14
 119
 120     // conversions
 121     template <class Duration2>
 122        time_point(const time_point<clock, Duration2>& t); // constexpr in C++14
 123
 124     // observer
 125
 126     duration time_since_epoch() const; // constexpr in C++14
 127
 128     // arithmetic
 129
 130     time_point& operator+=(const duration& d);
 131     time_point& operator-=(const duration& d);
 132
 133     // special values
 134
 135     static constexpr time_point min();
 136     static constexpr time_point max();
 137 };
 138
 139 } // chrono
 140
 141 // common_type traits
 142 template <class Rep1, class Period1, class Rep2, class Period2>
 143   struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;
 144
 145 template <class Clock, class Duration1, class Duration2>
 146   struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;
 147
 148 namespace chrono {
 149
 150 // duration arithmetic
 151 template <class Rep1, class Period1, class Rep2, class Period2>
 152   constexpr
 153   typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
 154   operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 155 template <class Rep1, class Period1, class Rep2, class Period2>
 156   constexpr
 157   typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
 158   operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 159 template <class Rep1, class Period, class Rep2>
 160   constexpr
 161   duration<typename common_type<Rep1, Rep2>::type, Period>
 162   operator*(const duration<Rep1, Period>& d, const Rep2& s);
 163 template <class Rep1, class Period, class Rep2>
 164   constexpr
 165   duration<typename common_type<Rep1, Rep2>::type, Period>
 166   operator*(const Rep1& s, const duration<Rep2, Period>& d);
 167 template <class Rep1, class Period, class Rep2>
 168   constexpr
 169   duration<typename common_type<Rep1, Rep2>::type, Period>
 170   operator/(const duration<Rep1, Period>& d, const Rep2& s);
 171 template <class Rep1, class Period1, class Rep2, class Period2>
 172   constexpr
 173   typename common_type<Rep1, Rep2>::type
 174   operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 175
 176 // duration comparisons
 177 template <class Rep1, class Period1, class Rep2, class Period2>
 178    constexpr
 179    bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 180 template <class Rep1, class Period1, class Rep2, class Period2>
 181    constexpr
 182    bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 183 template <class Rep1, class Period1, class Rep2, class Period2>
 184    constexpr
 185    bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 186 template <class Rep1, class Period1, class Rep2, class Period2>
 187    constexpr
 188    bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 189 template <class Rep1, class Period1, class Rep2, class Period2>
 190    constexpr
 191    bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 192 template <class Rep1, class Period1, class Rep2, class Period2>
 193    constexpr
 194    bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
 195
 196 // duration_cast
 197 template <class ToDuration, class Rep, class Period>
 198   ToDuration duration_cast(const duration<Rep, Period>& d);
 199
 200 template <class ToDuration, class Rep, class Period>
 201     constexpr ToDuration floor(const duration<Rep, Period>& d);    // C++17
 202 template <class ToDuration, class Rep, class Period>
 203     constexpr ToDuration ceil(const duration<Rep, Period>& d);     // C++17
 204 template <class ToDuration, class Rep, class Period>
 205     constexpr ToDuration round(const duration<Rep, Period>& d);    // C++17
 206
 207 // time_point arithmetic (all constexpr in C++14)
 208 template <class Clock, class Duration1, class Rep2, class Period2>
 209   time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
 210   operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 211 template <class Rep1, class Period1, class Clock, class Duration2>
 212   time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
 213   operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
 214 template <class Clock, class Duration1, class Rep2, class Period2>
 215   time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
 216   operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
 217 template <class Clock, class Duration1, class Duration2>
 218   typename common_type<Duration1, Duration2>::type
 219   operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 220
 221 // time_point comparisons (all constexpr in C++14)
 222 template <class Clock, class Duration1, class Duration2>
 223    bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 224 template <class Clock, class Duration1, class Duration2>
 225    bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 226 template <class Clock, class Duration1, class Duration2>
 227    bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 228 template <class Clock, class Duration1, class Duration2>
 229    bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 230 template <class Clock, class Duration1, class Duration2>
 231    bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 232 template <class Clock, class Duration1, class Duration2>
 233    bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
 234
 235 // time_point_cast (constexpr in C++14)
 236
 237 template <class ToDuration, class Clock, class Duration>
 238   time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
 239
 240 template <class ToDuration, class Clock, class Duration>
 241     constexpr time_point<Clock, ToDuration>
 242     floor(const time_point<Clock, Duration>& tp);                  // C++17
 243
 244 template <class ToDuration, class Clock, class Duration>
 245     constexpr time_point<Clock, ToDuration>
 246     ceil(const time_point<Clock, Duration>& tp);                   // C++17
 247
 248 template <class ToDuration, class Clock, class Duration>
 249     constexpr time_point<Clock, ToDuration>
 250     round(const time_point<Clock, Duration>& tp);                  // C++17
 251
 252 template <class Rep, class Period>
 253     constexpr duration<Rep, Period> abs(duration<Rep, Period> d);  // C++17
 254 // Clocks
 255
 256 class system_clock
 257 {
 258 public:
 259     typedef microseconds                     duration;
 260     typedef duration::rep                    rep;
 261     typedef duration::period                 period;
 262     typedef chrono::time_point<system_clock> time_point;
 263     static const bool is_steady =            false; // constexpr in C++14
 264
 265     static time_point now() noexcept;
 266     static time_t     to_time_t  (const time_point& __t) noexcept;
 267     static time_point from_time_t(time_t __t) noexcept;
 268 };
 269
 270 class steady_clock
 271 {
 272 public:
 273     typedef nanoseconds                                   duration;
 274     typedef duration::rep                                 rep;
 275     typedef duration::period                              period;
 276     typedef chrono::time_point<steady_clock, duration>    time_point;
 277     static const bool is_steady =                         true; // constexpr in C++14
 278
 279     static time_point now() noexcept;
 280 };
 281
 282 typedef steady_clock high_resolution_clock;
 283
 284 }  // chrono
 285
 286 constexpr chrono::hours                                 operator "" h(unsigned long long); // C++14
 287 constexpr chrono::duration<unspecified , ratio<3600,1>> operator "" h(long double); // C++14
 288 constexpr chrono::minutes                               operator "" min(unsigned long long); // C++14
 289 constexpr chrono::duration<unspecified , ratio<60,1>>   operator "" min(long double); // C++14
 290 constexpr chrono::seconds                               operator "" s(unsigned long long); // C++14
 291 constexpr chrono::duration<unspecified >                operator "" s(long double); // C++14
 292 constexpr chrono::milliseconds                          operator "" ms(unsigned long long); // C++14
 293 constexpr chrono::duration<unspecified , milli>         operator "" ms(long double); // C++14
 294 constexpr chrono::microseconds                          operator "" us(unsigned long long); // C++14
 295 constexpr chrono::duration<unspecified , micro>         operator "" us(long double); // C++14
 296 constexpr chrono::nanoseconds                           operator "" ns(unsigned long long); // C++14
 297 constexpr chrono::duration<unspecified , nano>          operator "" ns(long double); // C++14
 298
 299 }  // std
 300 */
 301
 302 #include <__config>
 303 #include <ctime>
 304 #include <type_traits>
 305 #include <ratio>
 306 #include <limits>
 307
 308 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 309 #pragma GCC system_header
 310 #endif
 311
 312 _LIBCPP_PUSH_MACROS
 313 #include <__undef_macros>
 314
 315
 316 _LIBCPP_BEGIN_NAMESPACE_STD
 317
 318 namespace chrono
 319 {
 320
 321 template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration;
 322
 323 template <class _Tp>
 324 struct __is_duration : false_type {};
 325
 326 template <class _Rep, class _Period>
 327 struct __is_duration<duration<_Rep, _Period> > : true_type  {};
 328
 329 template <class _Rep, class _Period>
 330 struct __is_duration<const duration<_Rep, _Period> > : true_type  {};
 331
 332 template <class _Rep, class _Period>
 333 struct __is_duration<volatile duration<_Rep, _Period> > : true_type  {};
 334
 335 template <class _Rep, class _Period>
 336 struct __is_duration<const volatile duration<_Rep, _Period> > : true_type  {};
 337
 338 } // chrono
 339
 340 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 341 struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>,
 342                                          chrono::duration<_Rep2, _Period2> >
 343 {
 344     typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
 345                              typename __ratio_gcd<_Period1, _Period2>::type> type;
 346 };
 347
 348 namespace chrono {
 349
 350 // duration_cast
 351
 352 template <class _FromDuration, class _ToDuration,
 353           class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type,
 354           bool = _Period::num == 1,
 355           bool = _Period::den == 1>
 356 struct __duration_cast;
 357
 358 template <class _FromDuration, class _ToDuration, class _Period>
 359 struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
 360 {
 361     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 362     _ToDuration operator()(const _FromDuration& __fd) const
 363     {
 364         return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
 365     }
 366 };
 367
 368 template <class _FromDuration, class _ToDuration, class _Period>
 369 struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
 370 {
 371     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 372     _ToDuration operator()(const _FromDuration& __fd) const
 373     {
 374         typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
 375         return _ToDuration(static_cast<typename _ToDuration::rep>(
 376                            static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
 377     }
 378 };
 379
 380 template <class _FromDuration, class _ToDuration, class _Period>
 381 struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
 382 {
 383     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 384     _ToDuration operator()(const _FromDuration& __fd) const
 385     {
 386         typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
 387         return _ToDuration(static_cast<typename _ToDuration::rep>(
 388                            static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
 389     }
 390 };
 391
 392 template <class _FromDuration, class _ToDuration, class _Period>
 393 struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
 394 {
 395     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 396     _ToDuration operator()(const _FromDuration& __fd) const
 397     {
 398         typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
 399         return _ToDuration(static_cast<typename _ToDuration::rep>(
 400                            static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
 401                                                           / static_cast<_Ct>(_Period::den)));
 402     }
 403 };
 404
 405 template <class _ToDuration, class _Rep, class _Period>
 406 inline _LIBCPP_INLINE_VISIBILITY
 407 _LIBCPP_CONSTEXPR
 408 typename enable_if
 409 <
 410     __is_duration<_ToDuration>::value,
 411     _ToDuration
 412 >::type
 413 duration_cast(const duration<_Rep, _Period>& __fd)
 414 {
 415     return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
 416 }
 417
 418 template <class _Rep>
 419 struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {};
 420
 421 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 422 template <class _Rep> _LIBCPP_CONSTEXPR bool treat_as_floating_point_v
 423     = treat_as_floating_point<_Rep>::value;
 424 #endif
 425
 426 template <class _Rep>
 427 struct _LIBCPP_TEMPLATE_VIS duration_values
 428 {
 429 public:
 430     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}
 431     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max()  {return numeric_limits<_Rep>::max();}
 432     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min()  {return numeric_limits<_Rep>::lowest();}
 433 };
 434
 435 #if _LIBCPP_STD_VER > 14
 436 template <class _ToDuration, class _Rep, class _Period>
 437 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 438 typename enable_if
 439 <
 440     __is_duration<_ToDuration>::value,
 441     _ToDuration
 442 >::type
 443 floor(const duration<_Rep, _Period>& __d)
 444 {
 445     _ToDuration __t = duration_cast<_ToDuration>(__d);
 446     if (__t > __d)
 447         __t = __t - _ToDuration{1};
 448     return __t;
 449 }
 450
 451 template <class _ToDuration, class _Rep, class _Period>
 452 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 453 typename enable_if
 454 <
 455     __is_duration<_ToDuration>::value,
 456     _ToDuration
 457 >::type
 458 ceil(const duration<_Rep, _Period>& __d)
 459 {
 460     _ToDuration __t = duration_cast<_ToDuration>(__d);
 461     if (__t < __d)
 462         __t = __t + _ToDuration{1};
 463     return __t;
 464 }
 465
 466 template <class _ToDuration, class _Rep, class _Period>
 467 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 468 typename enable_if
 469 <
 470     __is_duration<_ToDuration>::value,
 471     _ToDuration
 472 >::type
 473 round(const duration<_Rep, _Period>& __d)
 474 {
 475     _ToDuration __lower = floor<_ToDuration>(__d);
 476     _ToDuration __upper = __lower + _ToDuration{1};
 477     auto __lowerDiff = __d - __lower;
 478     auto __upperDiff = __upper - __d;
 479     if (__lowerDiff < __upperDiff)
 480         return __lower;
 481     if (__lowerDiff > __upperDiff)
 482         return __upper;
 483     return __lower.count() & 1 ? __upper : __lower;
 484 }
 485 #endif
 486
 487 // duration
 488
 489 template <class _Rep, class _Period>
 490 class _LIBCPP_TEMPLATE_VIS duration
 491 {
 492     static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
 493     static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
 494     static_assert(_Period::num > 0, "duration period must be positive");
 495
 496     template <class _R1, class _R2>
 497     struct __no_overflow
 498     {
 499     private:
 500         static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
 501         static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
 502         static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
 503         static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
 504         static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
 505         static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
 506         static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
 507
 508         template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
 509         struct __mul    // __overflow == false
 510         {
 511             static const intmax_t value = _Xp * _Yp;
 512         };
 513
 514         template <intmax_t _Xp, intmax_t _Yp>
 515         struct __mul<_Xp, _Yp, true>
 516         {
 517             static const intmax_t value = 1;
 518         };
 519
 520     public:
 521         static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
 522         typedef ratio<__mul<__n1, __d2, !value>::value,
 523                       __mul<__n2, __d1, !value>::value> type;
 524     };
 525
 526 public:
 527     typedef _Rep rep;
 528     typedef typename _Period::type period;
 529 private:
 530     rep __rep_;
 531 public:
 532
 533     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 534 #ifndef _LIBCPP_CXX03_LANG
 535         duration() = default;
 536 #else
 537         duration() {}
 538 #endif
 539
 540     template <class _Rep2>
 541         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 542         explicit duration(const _Rep2& __r,
 543             typename enable_if
 544             <
 545                is_convertible<_Rep2, rep>::value &&
 546                (treat_as_floating_point<rep>::value ||
 547                !treat_as_floating_point<_Rep2>::value)
 548             >::type* = 0)
 549                 : __rep_(__r) {}
 550
 551     // conversions
 552     template <class _Rep2, class _Period2>
 553         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 554         duration(const duration<_Rep2, _Period2>& __d,
 555             typename enable_if
 556             <
 557                 __no_overflow<_Period2, period>::value && (
 558                 treat_as_floating_point<rep>::value ||
 559                 (__no_overflow<_Period2, period>::type::den == 1 &&
 560                  !treat_as_floating_point<_Rep2>::value))
 561             >::type* = 0)
 562                 : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}
 563
 564     // observer
 565
 566     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
 567
 568     // arithmetic
 569
 570     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
 571     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
 572     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++()      {++__rep_; return *this;}
 573     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration  operator++(int)   {return duration(__rep_++);}
 574     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--()      {--__rep_; return *this;}
 575     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration  operator--(int)   {return duration(__rep_--);}
 576
 577     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
 578     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
 579
 580     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
 581     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
 582     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
 583     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
 584
 585     // special values
 586
 587     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());}
 588     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min()  {return duration(duration_values<rep>::min());}
 589     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max()  {return duration(duration_values<rep>::max());}
 590 };
 591
 592 typedef duration<long long,         nano> nanoseconds;
 593 typedef duration<long long,        micro> microseconds;
 594 typedef duration<long long,        milli> milliseconds;
 595 typedef duration<long long              > seconds;
 596 typedef duration<     long, ratio<  60> > minutes;
 597 typedef duration<     long, ratio<3600> > hours;
 598
 599 // Duration ==
 600
 601 template <class _LhsDuration, class _RhsDuration>
 602 struct __duration_eq
 603 {
 604     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 605     bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
 606         {
 607             typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
 608             return _Ct(__lhs).count() == _Ct(__rhs).count();
 609         }
 610 };
 611
 612 template <class _LhsDuration>
 613 struct __duration_eq<_LhsDuration, _LhsDuration>
 614 {
 615     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 616     bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
 617         {return __lhs.count() == __rhs.count();}
 618 };
 619
 620 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 621 inline _LIBCPP_INLINE_VISIBILITY
 622 _LIBCPP_CONSTEXPR
 623 bool
 624 operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 625 {
 626     return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
 627 }
 628
 629 // Duration !=
 630
 631 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 632 inline _LIBCPP_INLINE_VISIBILITY
 633 _LIBCPP_CONSTEXPR
 634 bool
 635 operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 636 {
 637     return !(__lhs == __rhs);
 638 }
 639
 640 // Duration <
 641
 642 template <class _LhsDuration, class _RhsDuration>
 643 struct __duration_lt
 644 {
 645     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 646     bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
 647         {
 648             typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
 649             return _Ct(__lhs).count() < _Ct(__rhs).count();
 650         }
 651 };
 652
 653 template <class _LhsDuration>
 654 struct __duration_lt<_LhsDuration, _LhsDuration>
 655 {
 656     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 657     bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
 658         {return __lhs.count() < __rhs.count();}
 659 };
 660
 661 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 662 inline _LIBCPP_INLINE_VISIBILITY
 663 _LIBCPP_CONSTEXPR
 664 bool
 665 operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 666 {
 667     return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
 668 }
 669
 670 // Duration >
 671
 672 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 673 inline _LIBCPP_INLINE_VISIBILITY
 674 _LIBCPP_CONSTEXPR
 675 bool
 676 operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 677 {
 678     return __rhs < __lhs;
 679 }
 680
 681 // Duration <=
 682
 683 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 684 inline _LIBCPP_INLINE_VISIBILITY
 685 _LIBCPP_CONSTEXPR
 686 bool
 687 operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 688 {
 689     return !(__rhs < __lhs);
 690 }
 691
 692 // Duration >=
 693
 694 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 695 inline _LIBCPP_INLINE_VISIBILITY
 696 _LIBCPP_CONSTEXPR
 697 bool
 698 operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 699 {
 700     return !(__lhs < __rhs);
 701 }
 702
 703 // Duration +
 704
 705 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 706 inline _LIBCPP_INLINE_VISIBILITY
 707 _LIBCPP_CONSTEXPR
 708 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 709 operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 710 {
 711     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 712     return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
 713 }
 714
 715 // Duration -
 716
 717 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 718 inline _LIBCPP_INLINE_VISIBILITY
 719 _LIBCPP_CONSTEXPR
 720 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 721 operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 722 {
 723     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 724     return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
 725 }
 726
 727 // Duration *
 728
 729 template <class _Rep1, class _Period, class _Rep2>
 730 inline _LIBCPP_INLINE_VISIBILITY
 731 _LIBCPP_CONSTEXPR
 732 typename enable_if
 733 <
 734     is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
 735     duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 736 >::type
 737 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 738 {
 739     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 740     typedef duration<_Cr, _Period> _Cd;
 741     return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
 742 }
 743
 744 template <class _Rep1, class _Period, class _Rep2>
 745 inline _LIBCPP_INLINE_VISIBILITY
 746 _LIBCPP_CONSTEXPR
 747 typename enable_if
 748 <
 749     is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
 750     duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 751 >::type
 752 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
 753 {
 754     return __d * __s;
 755 }
 756
 757 // Duration /
 758
 759 template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
 760 struct __duration_divide_result
 761 {
 762 };
 763
 764 template <class _Duration, class _Rep2,
 765     bool = is_convertible<_Rep2,
 766                           typename common_type<typename _Duration::rep, _Rep2>::type>::value>
 767 struct __duration_divide_imp
 768 {
 769 };
 770
 771 template <class _Rep1, class _Period, class _Rep2>
 772 struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
 773 {
 774     typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
 775 };
 776
 777 template <class _Rep1, class _Period, class _Rep2>
 778 struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
 779     : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
 780 {
 781 };
 782
 783 template <class _Rep1, class _Period, class _Rep2>
 784 inline _LIBCPP_INLINE_VISIBILITY
 785 _LIBCPP_CONSTEXPR
 786 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
 787 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 788 {
 789     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 790     typedef duration<_Cr, _Period> _Cd;
 791     return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
 792 }
 793
 794 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 795 inline _LIBCPP_INLINE_VISIBILITY
 796 _LIBCPP_CONSTEXPR
 797 typename common_type<_Rep1, _Rep2>::type
 798 operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 799 {
 800     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
 801     return _Ct(__lhs).count() / _Ct(__rhs).count();
 802 }
 803
 804 // Duration %
 805
 806 template <class _Rep1, class _Period, class _Rep2>
 807 inline _LIBCPP_INLINE_VISIBILITY
 808 _LIBCPP_CONSTEXPR
 809 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
 810 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 811 {
 812     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 813     typedef duration<_Cr, _Period> _Cd;
 814     return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
 815 }
 816
 817 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 818 inline _LIBCPP_INLINE_VISIBILITY
 819 _LIBCPP_CONSTEXPR
 820 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 821 operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 822 {
 823     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 824     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 825     return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
 826 }
 827
 828 //////////////////////////////////////////////////////////
 829 ///////////////////// time_point /////////////////////////
 830 //////////////////////////////////////////////////////////
 831
 832 template <class _Clock, class _Duration = typename _Clock::duration>
 833 class _LIBCPP_TEMPLATE_VIS time_point
 834 {
 835     static_assert(__is_duration<_Duration>::value,
 836                   "Second template parameter of time_point must be a std::chrono::duration");
 837 public:
 838     typedef _Clock                    clock;
 839     typedef _Duration                 duration;
 840     typedef typename duration::rep    rep;
 841     typedef typename duration::period period;
 842 private:
 843     duration __d_;
 844
 845 public:
 846     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {}
 847     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {}
 848
 849     // conversions
 850     template <class _Duration2>
 851     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 852     time_point(const time_point<clock, _Duration2>& t,
 853         typename enable_if
 854         <
 855             is_convertible<_Duration2, duration>::value
 856         >::type* = 0)
 857             : __d_(t.time_since_epoch()) {}
 858
 859     // observer
 860
 861     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;}
 862
 863     // arithmetic
 864
 865     _LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
 866     _LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
 867
 868     // special values
 869
 870     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());}
 871     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());}
 872 };
 873
 874 } // chrono
 875
 876 template <class _Clock, class _Duration1, class _Duration2>
 877 struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
 878                                          chrono::time_point<_Clock, _Duration2> >
 879 {
 880     typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
 881 };
 882
 883 namespace chrono {
 884
 885 template <class _ToDuration, class _Clock, class _Duration>
 886 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 887 time_point<_Clock, _ToDuration>
 888 time_point_cast(const time_point<_Clock, _Duration>& __t)
 889 {
 890     return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
 891 }
 892
 893 #if _LIBCPP_STD_VER > 14
 894 template <class _ToDuration, class _Clock, class _Duration>
 895 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 896 typename enable_if
 897 <
 898     __is_duration<_ToDuration>::value,
 899     time_point<_Clock, _ToDuration>
 900 >::type
 901 floor(const time_point<_Clock, _Duration>& __t)
 902 {
 903     return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())};
 904 }
 905
 906 template <class _ToDuration, class _Clock, class _Duration>
 907 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 908 typename enable_if
 909 <
 910     __is_duration<_ToDuration>::value,
 911     time_point<_Clock, _ToDuration>
 912 >::type
 913 ceil(const time_point<_Clock, _Duration>& __t)
 914 {
 915     return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())};
 916 }
 917
 918 template <class _ToDuration, class _Clock, class _Duration>
 919 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 920 typename enable_if
 921 <
 922     __is_duration<_ToDuration>::value,
 923     time_point<_Clock, _ToDuration>
 924 >::type
 925 round(const time_point<_Clock, _Duration>& __t)
 926 {
 927     return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())};
 928 }
 929
 930 template <class _Rep, class _Period>
 931 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 932 typename enable_if
 933 <
 934     numeric_limits<_Rep>::is_signed,
 935     duration<_Rep, _Period>
 936 >::type
 937 abs(duration<_Rep, _Period> __d)
 938 {
 939     return __d >= __d.zero() ? __d : -__d;
 940 }
 941 #endif
 942
 943 // time_point ==
 944
 945 template <class _Clock, class _Duration1, class _Duration2>
 946 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 947 bool
 948 operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 949 {
 950     return __lhs.time_since_epoch() == __rhs.time_since_epoch();
 951 }
 952
 953 // time_point !=
 954
 955 template <class _Clock, class _Duration1, class _Duration2>
 956 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 957 bool
 958 operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 959 {
 960     return !(__lhs == __rhs);
 961 }
 962
 963 // time_point <
 964
 965 template <class _Clock, class _Duration1, class _Duration2>
 966 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 967 bool
 968 operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 969 {
 970     return __lhs.time_since_epoch() < __rhs.time_since_epoch();
 971 }
 972
 973 // time_point >
 974
 975 template <class _Clock, class _Duration1, class _Duration2>
 976 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 977 bool
 978 operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 979 {
 980     return __rhs < __lhs;
 981 }
 982
 983 // time_point <=
 984
 985 template <class _Clock, class _Duration1, class _Duration2>
 986 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 987 bool
 988 operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 989 {
 990     return !(__rhs < __lhs);
 991 }
 992
 993 // time_point >=
 994
 995 template <class _Clock, class _Duration1, class _Duration2>
 996 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 997 bool
 998 operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 999 {
1000     return !(__lhs < __rhs);
1001 }
1002
1003 // time_point operator+(time_point x, duration y);
1004
1005 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
1006 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1007 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1008 operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1009 {
1010     typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
1011     return _Tr (__lhs.time_since_epoch() + __rhs);
1012 }
1013
1014 // time_point operator+(duration x, time_point y);
1015
1016 template <class _Rep1, class _Period1, class _Clock, class _Duration2>
1017 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1018 time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
1019 operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1020 {
1021     return __rhs + __lhs;
1022 }
1023
1024 // time_point operator-(time_point x, duration y);
1025
1026 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
1027 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1028 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1029 operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1030 {
1031     typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret;
1032     return _Ret(__lhs.time_since_epoch() -__rhs);
1033 }
1034
1035 // duration operator-(time_point x, time_point y);
1036
1037 template <class _Clock, class _Duration1, class _Duration2>
1038 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1039 typename common_type<_Duration1, _Duration2>::type
1040 operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1041 {
1042     return __lhs.time_since_epoch() - __rhs.time_since_epoch();
1043 }
1044
1045 //////////////////////////////////////////////////////////
1046 /////////////////////// clocks ///////////////////////////
1047 //////////////////////////////////////////////////////////
1048
1049 class _LIBCPP_TYPE_VIS system_clock
1050 {
1051 public:
1052     typedef microseconds                     duration;
1053     typedef duration::rep                    rep;
1054     typedef duration::period                 period;
1055     typedef chrono::time_point<system_clock> time_point;
1056     static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
1057
1058     static time_point now() _NOEXCEPT;
1059     static time_t     to_time_t  (const time_point& __t) _NOEXCEPT;
1060     static time_point from_time_t(time_t __t) _NOEXCEPT;
1061 };
1062
1063 #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
1064 class _LIBCPP_TYPE_VIS steady_clock
1065 {
1066 public:
1067     typedef nanoseconds                                   duration;
1068     typedef duration::rep                                 rep;
1069     typedef duration::period                              period;
1070     typedef chrono::time_point<steady_clock, duration>    time_point;
1071     static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true;
1072
1073     static time_point now() _NOEXCEPT;
1074 };
1075
1076 typedef steady_clock high_resolution_clock;
1077 #else
1078 typedef system_clock high_resolution_clock;
1079 #endif
1080
1081 } // chrono
1082
1083 #if _LIBCPP_STD_VER > 11
1084 // Suffixes for duration literals [time.duration.literals]
1085 inline namespace literals
1086 {
1087   inline namespace chrono_literals
1088   {
1089
1090     constexpr chrono::hours operator"" h(unsigned long long __h)
1091     {
1092         return chrono::hours(static_cast<chrono::hours::rep>(__h));
1093     }
1094
1095     constexpr chrono::duration<long double, ratio<3600,1>> operator"" h(long double __h)
1096     {
1097         return chrono::duration<long double, ratio<3600,1>>(__h);
1098     }
1099
1100
1101     constexpr chrono::minutes operator"" min(unsigned long long __m)
1102     {
1103         return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
1104     }
1105
1106     constexpr chrono::duration<long double, ratio<60,1>> operator"" min(long double __m)
1107     {
1108         return chrono::duration<long double, ratio<60,1>> (__m);
1109     }
1110
1111
1112     constexpr chrono::seconds operator"" s(unsigned long long __s)
1113     {
1114         return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
1115     }
1116
1117     constexpr chrono::duration<long double> operator"" s(long double __s)
1118     {
1119         return chrono::duration<long double> (__s);
1120     }
1121
1122
1123     constexpr chrono::milliseconds operator"" ms(unsigned long long __ms)
1124     {
1125         return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
1126     }
1127
1128     constexpr chrono::duration<long double, milli> operator"" ms(long double __ms)
1129     {
1130         return chrono::duration<long double, milli>(__ms);
1131     }
1132
1133
1134     constexpr chrono::microseconds operator"" us(unsigned long long __us)
1135     {
1136         return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
1137     }
1138
1139     constexpr chrono::duration<long double, micro> operator"" us(long double __us)
1140     {
1141         return chrono::duration<long double, micro> (__us);
1142     }
1143
1144
1145     constexpr chrono::nanoseconds operator"" ns(unsigned long long __ns)
1146     {
1147         return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
1148     }
1149
1150     constexpr chrono::duration<long double, nano> operator"" ns(long double __ns)
1151     {
1152         return chrono::duration<long double, nano> (__ns);
1153     }
1154
1155 }}
1156
1157 namespace chrono { // hoist the literals into namespace std::chrono
1158    using namespace literals::chrono_literals;
1159 }
1160
1161 #endif
1162
1163 _LIBCPP_END_NAMESPACE_STD
1164
1165 _LIBCPP_POP_MACROS
1166
1167 #endif  // _LIBCPP_CHRONO