Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(841)

Side by Side Diff: third_party/libcxx/include/chrono

Issue 75213003: Add libc++ and libc++abi to third-party. (Closed) Base URL: https://src.chromium.org/chrome/trunk/src/
Patch Set: Created 7 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
(Empty)
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 durat ion 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 // cons texpr 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, Per iod2>>;
141
142 template <class Clock, class Duration1, class Duration2>
143 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Cl ock, 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>& r hs);
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>& r hs);
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>& r hs);
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, Peri od2>& rhs);
177 template <class Rep1, class Period1, class Rep2, class Period2>
178 constexpr
179 bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Peri od2>& rhs);
180 template <class Rep1, class Period1, class Rep2, class Period2>
181 constexpr
182 bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Peri od2>& rhs);
183 template <class Rep1, class Period1, class Rep2, class Period2>
184 constexpr
185 bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Peri od2>& rhs);
186 template <class Rep1, class Period1, class Rep2, class Period2>
187 constexpr
188 bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Peri od2>& rhs);
189 template <class Rep1, class Period1, class Rep2, class Period2>
190 constexpr
191 bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Peri od2>& 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>>::ty pe>
200 operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period 2>& rhs);
201 template <class Rep1, class Period1, class Clock, class Duration2>
202 time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::ty pe>
203 operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration 2>& rhs);
204 template <class Clock, class Duration1, class Rep2, class Period2>
205 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::ty pe>
206 operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period 2>& 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, Dur ation2>& 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<Clo ck, Duration2>& rhs);
214 template <class Clock, class Duration1, class Duration2>
215 bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clo ck, Duration2>& rhs);
216 template <class Clock, class Duration1, class Duration2>
217 bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clo ck, Duration2>& rhs);
218 template <class Clock, class Duration1, class Duration2>
219 bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clo ck, Duration2>& rhs);
220 template <class Clock, class Duration1, class Duration2>
221 bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clo ck, Duration2>& rhs);
222 template <class Clock, class Duration1, class Duration2>
223 bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clo ck, 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 l ong long); // C++14
263 constexpr chrono::duration<unspecified , ratio<3600,1>> operator "" h(long doubl e); // C++14
264 constexpr chrono::minutes operator "" min(unsigned long long); // C++14
265 constexpr chrono::duration<unspecified , ratio<60,1>> operator "" min(long dou ble); // C++14
266 constexpr chrono::seconds operator "" s(unsigned l ong long); // C++14
267 constexpr chrono::duration<unspecified > operator "" s(long doubl e); // C++14
268 constexpr chrono::milliseconds operator "" ms(unsigned long long); // C++14
269 constexpr chrono::duration<unspecified , milli> operator "" ms(long doub le); // C++14
270 constexpr chrono::microseconds operator "" us(unsigned long long); // C++14
271 constexpr chrono::duration<unspecified , micro> operator "" us(long doub le); // C++14
272 constexpr chrono::nanoseconds operator "" ns(unsigned long long); // C++14
273 constexpr chrono::duration<unspecified , nano> operator "" ns(long doub le); // 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 dur ation;
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> typ e;
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 _FromDu ration::rep, intmax_t>::type _Ct;
349 return _ToDuration(static_cast<typename _ToDuration::rep>(
350 static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Pe riod::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 _FromDu ration::rep, intmax_t>::type _Ct;
361 return _ToDuration(static_cast<typename _ToDuration::rep>(
362 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Pe riod::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 _FromDu ration::rep, intmax_t>::type _Ct;
373 return _ToDuration(static_cast<typename _ToDuration::rep>(
374 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Pe riod::num)
375 / static_cast<_Ct>(_Pe riod::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 numer ic_limits<_Rep>::max();}
401 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() {return numer ic_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 no t be a duration");
410 static_assert(__is_ratio<_Period>::value, "Second template parameter of dura tion 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>::va lue;
418 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::va lue;
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_B IT - 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 {ret urn *this;}
488 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR duration operator-() const {ret urn duration(-__rep_);}
489 _LIBCPP_INLINE_VISIBILITY duration& operator++() {++__rep_; return *thi s;}
490 _LIBCPP_INLINE_VISIBILITY duration operator++(int) {return duration(__rep _++);}
491 _LIBCPP_INLINE_VISIBILITY duration& operator--() {--__rep_; return *thi s;}
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_ *= rh s; return *this;}
498 _LIBCPP_INLINE_VISIBILITY duration& operator/=(const rep& rhs) {__rep_ /= rh s; return *this;}
499 _LIBCPP_INLINE_VISIBILITY duration& operator%=(const rep& rhs) {__rep_ %= rh s; 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 d uration(duration_values<rep>::zero());}
505 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() {return d uration(duration_values<rep>::min());}
506 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() {return d uration(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, _Period 2>& __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, _Period 2>& __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, _Period 2>& __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, _Period 2>& __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, _Period 2>& __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, _Period 2>& __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> >::typ e
626 operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2 >& __rhs)
627 {
628 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Per iod2> >::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> >::typ e
638 operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2 >& __rhs)
639 {
640 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Per iod2> >::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, _Per iod2> >::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> >::typ e
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, _Per iod2> >::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, _Duratio n2>::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<_ToDurat ion>(__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, _Pe riod2>& __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, _Dura tion2>& __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, _Pe riod2>& __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 class _LIBCPP_TYPE_VIS steady_clock
930 {
931 public:
932 typedef nanoseconds duration;
933 typedef duration::rep rep;
934 typedef duration::period period;
935 typedef chrono::time_point<steady_clock, duration> time_point;
936 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true;
937
938 static time_point now() _NOEXCEPT;
939 };
940
941 typedef steady_clock high_resolution_clock;
942
943 } // chrono
944
945 #if _LIBCPP_STD_VER > 11
946 // Suffixes for duration literals [time.duration.literals]
947 inline namespace literals
948 {
949 inline namespace chrono_literals
950 {
951
952 constexpr chrono::hours operator"" h(unsigned long long __h)
953 {
954 return chrono::hours(static_cast<chrono::hours::rep>(__h));
955 }
956
957 constexpr chrono::duration<long double, ratio<3600,1>> operator"" h(long dou ble __h)
958 {
959 return chrono::duration<long double, ratio<3600,1>>(__h);
960 }
961
962
963 constexpr chrono::minutes operator"" min(unsigned long long __m)
964 {
965 return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
966 }
967
968 constexpr chrono::duration<long double, ratio<60,1>> operator"" min(long dou ble __m)
969 {
970 return chrono::duration<long double, ratio<60,1>> (__m);
971 }
972
973
974 constexpr chrono::seconds operator"" s(unsigned long long __s)
975 {
976 return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
977 }
978
979 constexpr chrono::duration<long double> operator"" s(long double __s)
980 {
981 return chrono::duration<long double> (__s);
982 }
983
984
985 constexpr chrono::milliseconds operator"" ms(unsigned long long __ms)
986 {
987 return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms) );
988 }
989
990 constexpr chrono::duration<long double, milli> operator"" ms(long double __m s)
991 {
992 return chrono::duration<long double, milli>(__ms);
993 }
994
995
996 constexpr chrono::microseconds operator"" us(unsigned long long __us)
997 {
998 return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us) );
999 }
1000
1001 constexpr chrono::duration<long double, micro> operator"" us(long double __u s)
1002 {
1003 return chrono::duration<long double, micro> (__us);
1004 }
1005
1006
1007 constexpr chrono::nanoseconds operator"" ns(unsigned long long __ns)
1008 {
1009 return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
1010 }
1011
1012 constexpr chrono::duration<long double, nano> operator"" ns(long double __ns )
1013 {
1014 return chrono::duration<long double, nano> (__ns);
1015 }
1016
1017 }}
1018
1019 namespace chrono { // hoist the literals into namespace std::chrono
1020 using namespace literals::chrono_literals;
1021 }
1022
1023 #endif
1024
1025 _LIBCPP_END_NAMESPACE_STD
1026
1027 #endif // _LIBCPP_CHRONO
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698