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