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> inline 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>
 423 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool treat_as_floating_point_v
 424     = treat_as_floating_point<_Rep>::value;
 425 #endif
 426
 427 template <class _Rep>
 428 struct _LIBCPP_TEMPLATE_VIS duration_values
 429 {
 430 public:
 431     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() {return _Rep(0);}
 432     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max()  {return numeric_limits<_Rep>::max();}
 433     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min()  {return numeric_limits<_Rep>::lowest();}
 434 };
 435
 436 #if _LIBCPP_STD_VER > 14
 437 template <class _ToDuration, class _Rep, class _Period>
 438 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 439 typename enable_if
 440 <
 441     __is_duration<_ToDuration>::value,
 442     _ToDuration
 443 >::type
 444 floor(const duration<_Rep, _Period>& __d)
 445 {
 446     _ToDuration __t = duration_cast<_ToDuration>(__d);
 447     if (__t > __d)
 448         __t = __t - _ToDuration{1};
 449     return __t;
 450 }
 451
 452 template <class _ToDuration, class _Rep, class _Period>
 453 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 454 typename enable_if
 455 <
 456     __is_duration<_ToDuration>::value,
 457     _ToDuration
 458 >::type
 459 ceil(const duration<_Rep, _Period>& __d)
 460 {
 461     _ToDuration __t = duration_cast<_ToDuration>(__d);
 462     if (__t < __d)
 463         __t = __t + _ToDuration{1};
 464     return __t;
 465 }
 466
 467 template <class _ToDuration, class _Rep, class _Period>
 468 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 469 typename enable_if
 470 <
 471     __is_duration<_ToDuration>::value,
 472     _ToDuration
 473 >::type
 474 round(const duration<_Rep, _Period>& __d)
 475 {
 476     _ToDuration __lower = floor<_ToDuration>(__d);
 477     _ToDuration __upper = __lower + _ToDuration{1};
 478     auto __lowerDiff = __d - __lower;
 479     auto __upperDiff = __upper - __d;
 480     if (__lowerDiff < __upperDiff)
 481         return __lower;
 482     if (__lowerDiff > __upperDiff)
 483         return __upper;
 484     return __lower.count() & 1 ? __upper : __lower;
 485 }
 486 #endif
 487
 488 // duration
 489
 490 template <class _Rep, class _Period>
 491 class _LIBCPP_TEMPLATE_VIS duration
 492 {
 493     static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
 494     static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
 495     static_assert(_Period::num > 0, "duration period must be positive");
 496
 497     template <class _R1, class _R2>
 498     struct __no_overflow
 499     {
 500     private:
 501         static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
 502         static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
 503         static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
 504         static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
 505         static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
 506         static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
 507         static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
 508
 509         template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
 510         struct __mul    // __overflow == false
 511         {
 512             static const intmax_t value = _Xp * _Yp;
 513         };
 514
 515         template <intmax_t _Xp, intmax_t _Yp>
 516         struct __mul<_Xp, _Yp, true>
 517         {
 518             static const intmax_t value = 1;
 519         };
 520
 521     public:
 522         static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
 523         typedef ratio<__mul<__n1, __d2, !value>::value,
 524                       __mul<__n2, __d1, !value>::value> type;
 525     };
 526
 527 public:
 528     typedef _Rep rep;
 529     typedef typename _Period::type period;
 530 private:
 531     rep __rep_;
 532 public:
 533
 534     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 535 #ifndef _LIBCPP_CXX03_LANG
 536         duration() = default;
 537 #else
 538         duration() {}
 539 #endif
 540
 541     template <class _Rep2>
 542         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 543         explicit duration(const _Rep2& __r,
 544             typename enable_if
 545             <
 546                is_convertible<_Rep2, rep>::value &&
 547                (treat_as_floating_point<rep>::value ||
 548                !treat_as_floating_point<_Rep2>::value)
 549             >::type* = 0)
 550                 : __rep_(__r) {}
 551
 552     // conversions
 553     template <class _Rep2, class _Period2>
 554         _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 555         duration(const duration<_Rep2, _Period2>& __d,
 556             typename enable_if
 557             <
 558                 __no_overflow<_Period2, period>::value && (
 559                 treat_as_floating_point<rep>::value ||
 560                 (__no_overflow<_Period2, period>::type::den == 1 &&
 561                  !treat_as_floating_point<_Rep2>::value))
 562             >::type* = 0)
 563                 : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}
 564
 565     // observer
 566
 567     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
 568
 569     // arithmetic
 570
 571     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
 572     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
 573     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++()      {++__rep_; return *this;}
 574     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration  operator++(int)   {return duration(__rep_++);}
 575     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--()      {--__rep_; return *this;}
 576     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration  operator--(int)   {return duration(__rep_--);}
 577
 578     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
 579     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
 580
 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 rep& rhs) {__rep_ %= rhs; return *this;}
 584     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
 585
 586     // special values
 587
 588     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() {return duration(duration_values<rep>::zero());}
 589     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min()  {return duration(duration_values<rep>::min());}
 590     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max()  {return duration(duration_values<rep>::max());}
 591 };
 592
 593 typedef duration<long long,         nano> nanoseconds;
 594 typedef duration<long long,        micro> microseconds;
 595 typedef duration<long long,        milli> milliseconds;
 596 typedef duration<long long              > seconds;
 597 typedef duration<     long, ratio<  60> > minutes;
 598 typedef duration<     long, ratio<3600> > hours;
 599
 600 // Duration ==
 601
 602 template <class _LhsDuration, class _RhsDuration>
 603 struct __duration_eq
 604 {
 605     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 606     bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
 607         {
 608             typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
 609             return _Ct(__lhs).count() == _Ct(__rhs).count();
 610         }
 611 };
 612
 613 template <class _LhsDuration>
 614 struct __duration_eq<_LhsDuration, _LhsDuration>
 615 {
 616     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 617     bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
 618         {return __lhs.count() == __rhs.count();}
 619 };
 620
 621 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 622 inline _LIBCPP_INLINE_VISIBILITY
 623 _LIBCPP_CONSTEXPR
 624 bool
 625 operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 626 {
 627     return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
 628 }
 629
 630 // Duration !=
 631
 632 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 633 inline _LIBCPP_INLINE_VISIBILITY
 634 _LIBCPP_CONSTEXPR
 635 bool
 636 operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 637 {
 638     return !(__lhs == __rhs);
 639 }
 640
 641 // Duration <
 642
 643 template <class _LhsDuration, class _RhsDuration>
 644 struct __duration_lt
 645 {
 646     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 647     bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
 648         {
 649             typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
 650             return _Ct(__lhs).count() < _Ct(__rhs).count();
 651         }
 652 };
 653
 654 template <class _LhsDuration>
 655 struct __duration_lt<_LhsDuration, _LhsDuration>
 656 {
 657     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 658     bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
 659         {return __lhs.count() < __rhs.count();}
 660 };
 661
 662 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 663 inline _LIBCPP_INLINE_VISIBILITY
 664 _LIBCPP_CONSTEXPR
 665 bool
 666 operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 667 {
 668     return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
 669 }
 670
 671 // Duration >
 672
 673 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 674 inline _LIBCPP_INLINE_VISIBILITY
 675 _LIBCPP_CONSTEXPR
 676 bool
 677 operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 678 {
 679     return __rhs < __lhs;
 680 }
 681
 682 // Duration <=
 683
 684 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 685 inline _LIBCPP_INLINE_VISIBILITY
 686 _LIBCPP_CONSTEXPR
 687 bool
 688 operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 689 {
 690     return !(__rhs < __lhs);
 691 }
 692
 693 // Duration >=
 694
 695 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 696 inline _LIBCPP_INLINE_VISIBILITY
 697 _LIBCPP_CONSTEXPR
 698 bool
 699 operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 700 {
 701     return !(__lhs < __rhs);
 702 }
 703
 704 // Duration +
 705
 706 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 707 inline _LIBCPP_INLINE_VISIBILITY
 708 _LIBCPP_CONSTEXPR
 709 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 710 operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 711 {
 712     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 713     return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
 714 }
 715
 716 // Duration -
 717
 718 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 719 inline _LIBCPP_INLINE_VISIBILITY
 720 _LIBCPP_CONSTEXPR
 721 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 722 operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 723 {
 724     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 725     return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
 726 }
 727
 728 // Duration *
 729
 730 template <class _Rep1, class _Period, class _Rep2>
 731 inline _LIBCPP_INLINE_VISIBILITY
 732 _LIBCPP_CONSTEXPR
 733 typename enable_if
 734 <
 735     is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
 736     duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 737 >::type
 738 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 739 {
 740     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 741     typedef duration<_Cr, _Period> _Cd;
 742     return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
 743 }
 744
 745 template <class _Rep1, class _Period, class _Rep2>
 746 inline _LIBCPP_INLINE_VISIBILITY
 747 _LIBCPP_CONSTEXPR
 748 typename enable_if
 749 <
 750     is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
 751     duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 752 >::type
 753 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
 754 {
 755     return __d * __s;
 756 }
 757
 758 // Duration /
 759
 760 template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
 761 struct __duration_divide_result
 762 {
 763 };
 764
 765 template <class _Duration, class _Rep2,
 766     bool = is_convertible<_Rep2,
 767                           typename common_type<typename _Duration::rep, _Rep2>::type>::value>
 768 struct __duration_divide_imp
 769 {
 770 };
 771
 772 template <class _Rep1, class _Period, class _Rep2>
 773 struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
 774 {
 775     typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
 776 };
 777
 778 template <class _Rep1, class _Period, class _Rep2>
 779 struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
 780     : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
 781 {
 782 };
 783
 784 template <class _Rep1, class _Period, class _Rep2>
 785 inline _LIBCPP_INLINE_VISIBILITY
 786 _LIBCPP_CONSTEXPR
 787 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
 788 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 789 {
 790     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 791     typedef duration<_Cr, _Period> _Cd;
 792     return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
 793 }
 794
 795 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 796 inline _LIBCPP_INLINE_VISIBILITY
 797 _LIBCPP_CONSTEXPR
 798 typename common_type<_Rep1, _Rep2>::type
 799 operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 800 {
 801     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
 802     return _Ct(__lhs).count() / _Ct(__rhs).count();
 803 }
 804
 805 // Duration %
 806
 807 template <class _Rep1, class _Period, class _Rep2>
 808 inline _LIBCPP_INLINE_VISIBILITY
 809 _LIBCPP_CONSTEXPR
 810 typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
 811 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
 812 {
 813     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 814     typedef duration<_Cr, _Period> _Cd;
 815     return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
 816 }
 817
 818 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
 819 inline _LIBCPP_INLINE_VISIBILITY
 820 _LIBCPP_CONSTEXPR
 821 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 822 operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
 823 {
 824     typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 825     typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 826     return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
 827 }
 828
 829 //////////////////////////////////////////////////////////
 830 ///////////////////// time_point /////////////////////////
 831 //////////////////////////////////////////////////////////
 832
 833 template <class _Clock, class _Duration = typename _Clock::duration>
 834 class _LIBCPP_TEMPLATE_VIS time_point
 835 {
 836     static_assert(__is_duration<_Duration>::value,
 837                   "Second template parameter of time_point must be a std::chrono::duration");
 838 public:
 839     typedef _Clock                    clock;
 840     typedef _Duration                 duration;
 841     typedef typename duration::rep    rep;
 842     typedef typename duration::period period;
 843 private:
 844     duration __d_;
 845
 846 public:
 847     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {}
 848     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {}
 849
 850     // conversions
 851     template <class _Duration2>
 852     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 853     time_point(const time_point<clock, _Duration2>& t,
 854         typename enable_if
 855         <
 856             is_convertible<_Duration2, duration>::value
 857         >::type* = 0)
 858             : __d_(t.time_since_epoch()) {}
 859
 860     // observer
 861
 862     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;}
 863
 864     // arithmetic
 865
 866     _LIBCPP_INLINE_VISIBILITY time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
 867     _LIBCPP_INLINE_VISIBILITY time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
 868
 869     // special values
 870
 871     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() {return time_point(duration::min());}
 872     _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() {return time_point(duration::max());}
 873 };
 874
 875 } // chrono
 876
 877 template <class _Clock, class _Duration1, class _Duration2>
 878 struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
 879                                          chrono::time_point<_Clock, _Duration2> >
 880 {
 881     typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
 882 };
 883
 884 namespace chrono {
 885
 886 template <class _ToDuration, class _Clock, class _Duration>
 887 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 888 time_point<_Clock, _ToDuration>
 889 time_point_cast(const time_point<_Clock, _Duration>& __t)
 890 {
 891     return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
 892 }
 893
 894 #if _LIBCPP_STD_VER > 14
 895 template <class _ToDuration, class _Clock, class _Duration>
 896 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 897 typename enable_if
 898 <
 899     __is_duration<_ToDuration>::value,
 900     time_point<_Clock, _ToDuration>
 901 >::type
 902 floor(const time_point<_Clock, _Duration>& __t)
 903 {
 904     return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())};
 905 }
 906
 907 template <class _ToDuration, class _Clock, class _Duration>
 908 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 909 typename enable_if
 910 <
 911     __is_duration<_ToDuration>::value,
 912     time_point<_Clock, _ToDuration>
 913 >::type
 914 ceil(const time_point<_Clock, _Duration>& __t)
 915 {
 916     return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())};
 917 }
 918
 919 template <class _ToDuration, class _Clock, class _Duration>
 920 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 921 typename enable_if
 922 <
 923     __is_duration<_ToDuration>::value,
 924     time_point<_Clock, _ToDuration>
 925 >::type
 926 round(const time_point<_Clock, _Duration>& __t)
 927 {
 928     return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())};
 929 }
 930
 931 template <class _Rep, class _Period>
 932 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 933 typename enable_if
 934 <
 935     numeric_limits<_Rep>::is_signed,
 936     duration<_Rep, _Period>
 937 >::type
 938 abs(duration<_Rep, _Period> __d)
 939 {
 940     return __d >= __d.zero() ? __d : -__d;
 941 }
 942 #endif
 943
 944 // time_point ==
 945
 946 template <class _Clock, class _Duration1, class _Duration2>
 947 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 948 bool
 949 operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 950 {
 951     return __lhs.time_since_epoch() == __rhs.time_since_epoch();
 952 }
 953
 954 // time_point !=
 955
 956 template <class _Clock, class _Duration1, class _Duration2>
 957 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 958 bool
 959 operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 960 {
 961     return !(__lhs == __rhs);
 962 }
 963
 964 // time_point <
 965
 966 template <class _Clock, class _Duration1, class _Duration2>
 967 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 968 bool
 969 operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 970 {
 971     return __lhs.time_since_epoch() < __rhs.time_since_epoch();
 972 }
 973
 974 // time_point >
 975
 976 template <class _Clock, class _Duration1, class _Duration2>
 977 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 978 bool
 979 operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 980 {
 981     return __rhs < __lhs;
 982 }
 983
 984 // time_point <=
 985
 986 template <class _Clock, class _Duration1, class _Duration2>
 987 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 988 bool
 989 operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
 990 {
 991     return !(__rhs < __lhs);
 992 }
 993
 994 // time_point >=
 995
 996 template <class _Clock, class _Duration1, class _Duration2>
 997 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
 998 bool
 999 operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1000 {
1001     return !(__lhs < __rhs);
1002 }
1003
1004 // time_point operator+(time_point x, duration y);
1005
1006 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
1007 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1008 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1009 operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1010 {
1011     typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
1012     return _Tr (__lhs.time_since_epoch() + __rhs);
1013 }
1014
1015 // time_point operator+(duration x, time_point y);
1016
1017 template <class _Rep1, class _Period1, class _Clock, class _Duration2>
1018 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1019 time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
1020 operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1021 {
1022     return __rhs + __lhs;
1023 }
1024
1025 // time_point operator-(time_point x, duration y);
1026
1027 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
1028 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1029 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1030 operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1031 {
1032     typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret;
1033     return _Ret(__lhs.time_since_epoch() -__rhs);
1034 }
1035
1036 // duration operator-(time_point x, time_point y);
1037
1038 template <class _Clock, class _Duration1, class _Duration2>
1039 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
1040 typename common_type<_Duration1, _Duration2>::type
1041 operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1042 {
1043     return __lhs.time_since_epoch() - __rhs.time_since_epoch();
1044 }
1045
1046 //////////////////////////////////////////////////////////
1047 /////////////////////// clocks ///////////////////////////
1048 //////////////////////////////////////////////////////////
1049
1050 class _LIBCPP_TYPE_VIS system_clock
1051 {
1052 public:
1053     typedef microseconds                     duration;
1054     typedef duration::rep                    rep;
1055     typedef duration::period                 period;
1056     typedef chrono::time_point<system_clock> time_point;
1057     static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
1058
1059     static time_point now() _NOEXCEPT;
1060     static time_t     to_time_t  (const time_point& __t) _NOEXCEPT;
1061     static time_point from_time_t(time_t __t) _NOEXCEPT;
1062 };
1063
1064 #ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
1065 class _LIBCPP_TYPE_VIS steady_clock
1066 {
1067 public:
1068     typedef nanoseconds                                   duration;
1069     typedef duration::rep                                 rep;
1070     typedef duration::period                              period;
1071     typedef chrono::time_point<steady_clock, duration>    time_point;
1072     static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true;
1073
1074     static time_point now() _NOEXCEPT;
1075 };
1076
1077 typedef steady_clock high_resolution_clock;
1078 #else
1079 typedef system_clock high_resolution_clock;
1080 #endif
1081
1082 } // chrono
1083
1084 #if _LIBCPP_STD_VER > 11
1085 // Suffixes for duration literals [time.duration.literals]
1086 inline namespace literals
1087 {
1088   inline namespace chrono_literals
1089   {
1090
1091     constexpr chrono::hours operator""h(unsigned long long __h)
1092     {
1093         return chrono::hours(static_cast<chrono::hours::rep>(__h));
1094     }
1095
1096     constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
1097     {
1098         return chrono::duration<long double, ratio<3600,1>>(__h);
1099     }
1100
1101
1102     constexpr chrono::minutes operator""min(unsigned long long __m)
1103     {
1104         return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
1105     }
1106
1107     constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m)
1108     {
1109         return chrono::duration<long double, ratio<60,1>> (__m);
1110     }
1111
1112
1113     constexpr chrono::seconds operator""s(unsigned long long __s)
1114     {
1115         return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
1116     }
1117
1118     constexpr chrono::duration<long double> operator""s(long double __s)
1119     {
1120         return chrono::duration<long double> (__s);
1121     }
1122
1123
1124     constexpr chrono::milliseconds operator""ms(unsigned long long __ms)
1125     {
1126         return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
1127     }
1128
1129     constexpr chrono::duration<long double, milli> operator""ms(long double __ms)
1130     {
1131         return chrono::duration<long double, milli>(__ms);
1132     }
1133
1134
1135     constexpr chrono::microseconds operator""us(unsigned long long __us)
1136     {
1137         return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
1138     }
1139
1140     constexpr chrono::duration<long double, micro> operator""us(long double __us)
1141     {
1142         return chrono::duration<long double, micro> (__us);
1143     }
1144
1145
1146     constexpr chrono::nanoseconds operator""ns(unsigned long long __ns)
1147     {
1148         return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
1149     }
1150
1151     constexpr chrono::duration<long double, nano> operator""ns(long double __ns)
1152     {
1153         return chrono::duration<long double, nano> (__ns);
1154     }
1155
1156 }}
1157
1158 namespace chrono { // hoist the literals into namespace std::chrono
1159    using namespace literals::chrono_literals;
1160 }
1161
1162 #endif
1163
1164 _LIBCPP_END_NAMESPACE_STD
1165
1166 _LIBCPP_POP_MACROS
1167
1168 #endif  // _LIBCPP_CHRONO