blob: cabf18c038c19735ee59efbdc1849b884d3c9e43 [file] [log] [blame]
Howard Hinnantc51e1022010-05-11 19:42:16 +00001// -*- C++ -*-
2//===---------------------------- chrono ----------------------------------===//
3//
Howard Hinnantc566dc32010-05-11 21:36:01 +00004// The LLVM Compiler Infrastructure
Howard Hinnantc51e1022010-05-11 19:42:16 +00005//
Howard Hinnantee11c312010-11-16 22:09:02 +00006// This file is dual licensed under the MIT and the University of Illinois Open
7// Source Licenses. See LICENSE.TXT for details.
Howard Hinnantc51e1022010-05-11 19:42:16 +00008//
9//===----------------------------------------------------------------------===//
10
11#ifndef _LIBCPP_CHRONO
12#define _LIBCPP_CHRONO
13
14/*
15 chrono synopsis
16
17namespace std
18{
19namespace chrono
20{
21
22template <class ToDuration, class Rep, class Period>
Howard Hinnantcf3143c2012-07-13 19:17:27 +000023constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +000024ToDuration
25duration_cast(const duration<Rep, Period>& fd);
26
27template <class Rep> struct treat_as_floating_point : is_floating_point<Rep> {};
28
Marshall Clowf1bf62f2018-01-02 17:17:01 +000029template <class Rep> inline constexpr bool treat_as_floating_point_v
Marshall Clow59581f02015-11-30 05:39:30 +000030 = treat_as_floating_point<Rep>::value; // C++17
31
Howard Hinnantc51e1022010-05-11 19:42:16 +000032template <class Rep>
33struct duration_values
34{
35public:
Marshall Clowb1296bd2018-11-13 17:22:41 +000036 static constexpr Rep zero(); // noexcept in C++20
37 static constexpr Rep max(); // noexcept in C++20
38 static constexpr Rep min(); // noexcept in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000039};
40
41// duration
42
43template <class Rep, class Period = ratio<1>>
44class 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");
49public:
50 typedef Rep rep;
Marshall Clow76200b22017-03-21 18:38:57 +000051 typedef typename _Period::type period;
Howard Hinnantc51e1022010-05-11 19:42:16 +000052
Howard Hinnantcf3143c2012-07-13 19:17:27 +000053 constexpr duration() = default;
Howard Hinnantc51e1022010-05-11 19:42:16 +000054 template <class Rep2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +000055 constexpr explicit duration(const Rep2& r,
Howard Hinnantc51e1022010-05-11 19:42:16 +000056 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>
Howard Hinnantcf3143c2012-07-13 19:17:27 +000065 constexpr duration(const duration<Rep2, Period2>& d,
Howard Hinnantc51e1022010-05-11 19:42:16 +000066 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
Howard Hinnantcf3143c2012-07-13 19:17:27 +000074 constexpr rep count() const;
Howard Hinnantc51e1022010-05-11 19:42:16 +000075
76 // arithmetic
77
Marshall Clow76200b22017-03-21 18:38:57 +000078 constexpr common_type<duration>::type operator+() const;
79 constexpr common_type<duration>::type operator-() const;
Marshall Clowdf247eb2018-08-29 23:02:15 +000080 constexpr duration& operator++(); // constexpr in C++17
81 constexpr duration operator++(int); // constexpr in C++17
82 constexpr duration& operator--(); // constexpr in C++17
83 constexpr duration operator--(int); // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +000084
Marshall Clowdf247eb2018-08-29 23:02:15 +000085 constexpr duration& operator+=(const duration& d); // constexpr in C++17
86 constexpr duration& operator-=(const duration& d); // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +000087
Marshall Clowdf247eb2018-08-29 23:02:15 +000088 duration& operator*=(const rep& rhs); // constexpr in C++17
89 duration& operator/=(const rep& rhs); // constexpr in C++17
90 duration& operator%=(const rep& rhs); // constexpr in C++17
91 duration& operator%=(const duration& rhs); // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +000092
93 // special values
94
Marshall Clowb1296bd2018-11-13 17:22:41 +000095 static constexpr duration zero(); // noexcept in C++20
96 static constexpr duration min(); // noexcept in C++20
97 static constexpr duration max(); // noexcept in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +000098};
99
100typedef duration<long long, nano> nanoseconds;
101typedef duration<long long, micro> microseconds;
102typedef duration<long long, milli> milliseconds;
103typedef duration<long long > seconds;
104typedef duration< long, ratio< 60> > minutes;
105typedef duration< long, ratio<3600> > hours;
106
107template <class Clock, class Duration = typename Clock::duration>
108class time_point
109{
110public:
111 typedef Clock clock;
112 typedef Duration duration;
113 typedef typename duration::rep rep;
114 typedef typename duration::period period;
115private:
116 duration d_; // exposition only
117
118public:
Marshall Clow5c459c92013-07-31 19:32:19 +0000119 time_point(); // has value "epoch" // constexpr in C++14
120 explicit time_point(const duration& d); // same as time_point() + d // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000121
122 // conversions
123 template <class Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +0000124 time_point(const time_point<clock, Duration2>& t); // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000125
126 // observer
127
Marshall Clow5c459c92013-07-31 19:32:19 +0000128 duration time_since_epoch() const; // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000129
130 // arithmetic
131
Marshall Clowdf247eb2018-08-29 23:02:15 +0000132 time_point& operator+=(const duration& d); // constexpr in C++17
133 time_point& operator-=(const duration& d); // constexpr in C++17
Howard Hinnantc51e1022010-05-11 19:42:16 +0000134
135 // special values
136
Marshall Clowb1296bd2018-11-13 17:22:41 +0000137 static constexpr time_point min(); // noexcept in C++20
138 static constexpr time_point max(); // noexcept in C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000139};
140
141} // chrono
142
143// common_type traits
144template <class Rep1, class Period1, class Rep2, class Period2>
145 struct common_type<chrono::duration<Rep1, Period1>, chrono::duration<Rep2, Period2>>;
146
147template <class Clock, class Duration1, class Duration2>
148 struct common_type<chrono::time_point<Clock, Duration1>, chrono::time_point<Clock, Duration2>>;
149
150namespace chrono {
151
Marshall Clow40ca0c12018-07-18 17:37:51 +0000152
153template<class T> struct is_clock; // C++20
154template<class T> inline constexpr bool is_clock_v = is_clock<T>::value; // C++20
155
156
Howard Hinnantc51e1022010-05-11 19:42:16 +0000157// duration arithmetic
158template <class Rep1, class Period1, class Rep2, class Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000159 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000160 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
161 operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
162template <class Rep1, class Period1, class Rep2, class Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000163 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000164 typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type
165 operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
166template <class Rep1, class Period, class Rep2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000167 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000168 duration<typename common_type<Rep1, Rep2>::type, Period>
169 operator*(const duration<Rep1, Period>& d, const Rep2& s);
170template <class Rep1, class Period, class Rep2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000171 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000172 duration<typename common_type<Rep1, Rep2>::type, Period>
173 operator*(const Rep1& s, const duration<Rep2, Period>& d);
174template <class Rep1, class Period, class Rep2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000175 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000176 duration<typename common_type<Rep1, Rep2>::type, Period>
177 operator/(const duration<Rep1, Period>& d, const Rep2& s);
178template <class Rep1, class Period1, class Rep2, class Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000179 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000180 typename common_type<Rep1, Rep2>::type
181 operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
182
183// duration comparisons
184template <class Rep1, class Period1, class Rep2, class Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000185 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000186 bool operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
187template <class Rep1, class Period1, class Rep2, class Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000188 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000189 bool operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
190template <class Rep1, class Period1, class Rep2, class Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000191 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000192 bool operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
193template <class Rep1, class Period1, class Rep2, class Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000194 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000195 bool operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
196template <class Rep1, class Period1, class Rep2, class Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000197 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000198 bool operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
199template <class Rep1, class Period1, class Rep2, class Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000200 constexpr
Howard Hinnantc51e1022010-05-11 19:42:16 +0000201 bool operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs);
202
203// duration_cast
204template <class ToDuration, class Rep, class Period>
205 ToDuration duration_cast(const duration<Rep, Period>& d);
206
Marshall Clowf2eabaf2015-11-05 19:33:59 +0000207template <class ToDuration, class Rep, class Period>
208 constexpr ToDuration floor(const duration<Rep, Period>& d); // C++17
209template <class ToDuration, class Rep, class Period>
210 constexpr ToDuration ceil(const duration<Rep, Period>& d); // C++17
211template <class ToDuration, class Rep, class Period>
212 constexpr ToDuration round(const duration<Rep, Period>& d); // C++17
213
Marshall Clow40ca0c12018-07-18 17:37:51 +0000214// duration I/O is elsewhere
215
Marshall Clow5c459c92013-07-31 19:32:19 +0000216// time_point arithmetic (all constexpr in C++14)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000217template <class Clock, class Duration1, class Rep2, class Period2>
218 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
219 operator+(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
220template <class Rep1, class Period1, class Clock, class Duration2>
221 time_point<Clock, typename common_type<duration<Rep1, Period1>, Duration2>::type>
222 operator+(const duration<Rep1, Period1>& lhs, const time_point<Clock, Duration2>& rhs);
223template <class Clock, class Duration1, class Rep2, class Period2>
224 time_point<Clock, typename common_type<Duration1, duration<Rep2, Period2>>::type>
225 operator-(const time_point<Clock, Duration1>& lhs, const duration<Rep2, Period2>& rhs);
226template <class Clock, class Duration1, class Duration2>
227 typename common_type<Duration1, Duration2>::type
228 operator-(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
229
Marshall Clow5c459c92013-07-31 19:32:19 +0000230// time_point comparisons (all constexpr in C++14)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000231template <class Clock, class Duration1, class Duration2>
232 bool operator==(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
233template <class Clock, class Duration1, class Duration2>
234 bool operator!=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
235template <class Clock, class Duration1, class Duration2>
236 bool operator< (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
237template <class Clock, class Duration1, class Duration2>
238 bool operator<=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
239template <class Clock, class Duration1, class Duration2>
240 bool operator> (const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
241template <class Clock, class Duration1, class Duration2>
242 bool operator>=(const time_point<Clock, Duration1>& lhs, const time_point<Clock, Duration2>& rhs);
243
Marshall Clow5c459c92013-07-31 19:32:19 +0000244// time_point_cast (constexpr in C++14)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000245
246template <class ToDuration, class Clock, class Duration>
247 time_point<Clock, ToDuration> time_point_cast(const time_point<Clock, Duration>& t);
248
Marshall Clowf2eabaf2015-11-05 19:33:59 +0000249template <class ToDuration, class Clock, class Duration>
250 constexpr time_point<Clock, ToDuration>
251 floor(const time_point<Clock, Duration>& tp); // C++17
252
253template <class ToDuration, class Clock, class Duration>
254 constexpr time_point<Clock, ToDuration>
255 ceil(const time_point<Clock, Duration>& tp); // C++17
256
257template <class ToDuration, class Clock, class Duration>
258 constexpr time_point<Clock, ToDuration>
259 round(const time_point<Clock, Duration>& tp); // C++17
260
261template <class Rep, class Period>
262 constexpr duration<Rep, Period> abs(duration<Rep, Period> d); // C++17
Marshall Clow40ca0c12018-07-18 17:37:51 +0000263
Howard Hinnantc51e1022010-05-11 19:42:16 +0000264// Clocks
265
266class system_clock
267{
268public:
269 typedef microseconds duration;
270 typedef duration::rep rep;
271 typedef duration::period period;
272 typedef chrono::time_point<system_clock> time_point;
Marshall Clow5c459c92013-07-31 19:32:19 +0000273 static const bool is_steady = false; // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000274
Howard Hinnantaa54ac42011-05-28 18:34:36 +0000275 static time_point now() noexcept;
276 static time_t to_time_t (const time_point& __t) noexcept;
277 static time_point from_time_t(time_t __t) noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000278};
279
Marshall Clow40ca0c12018-07-18 17:37:51 +0000280template <class Duration>
281 using sys_time = time_point<system_clock, Duration>; // C++20
282using sys_seconds = sys_time<seconds>; // C++20
283using sys_days = sys_time<days>; // C++20
284
285class utc_clock; // C++20
286
287template <class Duration>
288 using utc_time = time_point<utc_clock, Duration>; // C++20
289using utc_seconds = utc_time<seconds>; // C++20
290
291class tai_clock; // C++20
292
293template <class Duration>
294 using tai_time = time_point<tai_clock, Duration>; // C++20
295using tai_seconds = tai_time<seconds>; // C++20
296
297class file_clock; // C++20
298
299template<class Duration>
300 using file_time = time_point<file_clock, Duration>; // C++20
301
Howard Hinnantc8dbd222010-11-20 19:16:30 +0000302class steady_clock
Howard Hinnantc51e1022010-05-11 19:42:16 +0000303{
304public:
305 typedef nanoseconds duration;
306 typedef duration::rep rep;
307 typedef duration::period period;
Howard Hinnantc8dbd222010-11-20 19:16:30 +0000308 typedef chrono::time_point<steady_clock, duration> time_point;
Marshall Clow5c459c92013-07-31 19:32:19 +0000309 static const bool is_steady = true; // constexpr in C++14
Howard Hinnantc51e1022010-05-11 19:42:16 +0000310
Howard Hinnantaa54ac42011-05-28 18:34:36 +0000311 static time_point now() noexcept;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000312};
313
Howard Hinnantc8dbd222010-11-20 19:16:30 +0000314typedef steady_clock high_resolution_clock;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000315
Marshall Clow40ca0c12018-07-18 17:37:51 +0000316// 25.7.8, local time // C++20
317struct local_t {};
318template<class Duration>
319 using local_time = time_point<local_t, Duration>;
320using local_seconds = local_time<seconds>;
321using local_days = local_time<days>;
322
323// 25.7.9, time_point conversions template<class DestClock, class SourceClock> // C++20
324struct clock_time_conversion;
325
326template<class DestClock, class SourceClock, class Duration>
327 auto clock_cast(const time_point<SourceClock, Duration>& t);
Louis Dionne44bcff92018-08-03 22:36:53 +0000328
Marshall Clow40ca0c12018-07-18 17:37:51 +0000329// 25.8.2, class last_spec // C++20
330struct last_spec;
331
332// 25.8.3, class day // C++20
333
334class day;
335constexpr bool operator==(const day& x, const day& y) noexcept;
336constexpr bool operator!=(const day& x, const day& y) noexcept;
337constexpr bool operator< (const day& x, const day& y) noexcept;
338constexpr bool operator> (const day& x, const day& y) noexcept;
339constexpr bool operator<=(const day& x, const day& y) noexcept;
340constexpr bool operator>=(const day& x, const day& y) noexcept;
341constexpr day operator+(const day& x, const days& y) noexcept;
342constexpr day operator+(const days& x, const day& y) noexcept;
343constexpr day operator-(const day& x, const days& y) noexcept;
344constexpr days operator-(const day& x, const day& y) noexcept;
345
346// 25.8.4, class month // C++20
347class month;
348constexpr bool operator==(const month& x, const month& y) noexcept;
349constexpr bool operator!=(const month& x, const month& y) noexcept;
350constexpr bool operator< (const month& x, const month& y) noexcept;
351constexpr bool operator> (const month& x, const month& y) noexcept;
352constexpr bool operator<=(const month& x, const month& y) noexcept;
353constexpr bool operator>=(const month& x, const month& y) noexcept;
354constexpr month operator+(const month& x, const months& y) noexcept;
355constexpr month operator+(const months& x, const month& y) noexcept;
356constexpr month operator-(const month& x, const months& y) noexcept;
357constexpr months operator-(const month& x, const month& y) noexcept;
358
359// 25.8.5, class year // C++20
360class year;
361constexpr bool operator==(const year& x, const year& y) noexcept;
362constexpr bool operator!=(const year& x, const year& y) noexcept;
363constexpr bool operator< (const year& x, const year& y) noexcept;
364constexpr bool operator> (const year& x, const year& y) noexcept;
365constexpr bool operator<=(const year& x, const year& y) noexcept;
366constexpr bool operator>=(const year& x, const year& y) noexcept;
367constexpr year operator+(const year& x, const years& y) noexcept;
368constexpr year operator+(const years& x, const year& y) noexcept;
369constexpr year operator-(const year& x, const years& y) noexcept;
370constexpr years operator-(const year& x, const year& y) noexcept;
371
372// 25.8.6, class weekday // C++20
373class weekday;
374
375constexpr bool operator==(const weekday& x, const weekday& y) noexcept;
376constexpr bool operator!=(const weekday& x, const weekday& y) noexcept;
377constexpr weekday operator+(const weekday& x, const days& y) noexcept;
378constexpr weekday operator+(const days& x, const weekday& y) noexcept;
379constexpr weekday operator-(const weekday& x, const days& y) noexcept;
380constexpr days operator-(const weekday& x, const weekday& y) noexcept;
381
382// 25.8.7, class weekday_indexed // C++20
383
384class weekday_indexed;
385constexpr bool operator==(const weekday_indexed& x, const weekday_indexed& y) noexcept;
386constexpr bool operator!=(const weekday_indexed& x, const weekday_indexed& y) noexcept;
387
388// 25.8.8, class weekday_last // C++20
389class weekday_last;
390
391constexpr bool operator==(const weekday_last& x, const weekday_last& y) noexcept;
392constexpr bool operator!=(const weekday_last& x, const weekday_last& y) noexcept;
393
394// 25.8.9, class month_day // C++20
395class month_day;
396
397constexpr bool operator==(const month_day& x, const month_day& y) noexcept;
398constexpr bool operator!=(const month_day& x, const month_day& y) noexcept;
399constexpr bool operator< (const month_day& x, const month_day& y) noexcept;
400constexpr bool operator> (const month_day& x, const month_day& y) noexcept;
401constexpr bool operator<=(const month_day& x, const month_day& y) noexcept;
402constexpr bool operator>=(const month_day& x, const month_day& y) noexcept;
403
404
405// 25.8.10, class month_day_last // C++20
406class month_day_last;
407
408constexpr bool operator==(const month_day_last& x, const month_day_last& y) noexcept;
409constexpr bool operator!=(const month_day_last& x, const month_day_last& y) noexcept;
410constexpr bool operator< (const month_day_last& x, const month_day_last& y) noexcept;
411constexpr bool operator> (const month_day_last& x, const month_day_last& y) noexcept;
412constexpr bool operator<=(const month_day_last& x, const month_day_last& y) noexcept;
413constexpr bool operator>=(const month_day_last& x, const month_day_last& y) noexcept;
414
415// 25.8.11, class month_weekday // C++20
416class month_weekday;
417
418constexpr bool operator==(const month_weekday& x, const month_weekday& y) noexcept;
419constexpr bool operator!=(const month_weekday& x, const month_weekday& y) noexcept;
420
421// 25.8.12, class month_weekday_last // C++20
422class month_weekday_last;
423
424constexpr bool operator==(const month_weekday_last& x, const month_weekday_last& y) noexcept;
425constexpr bool operator!=(const month_weekday_last& x, const month_weekday_last& y) noexcept;
426
427
428// 25.8.13, class year_month // C++20
429class year_month;
430
431constexpr bool operator==(const year_month& x, const year_month& y) noexcept;
432constexpr bool operator!=(const year_month& x, const year_month& y) noexcept;
433constexpr bool operator< (const year_month& x, const year_month& y) noexcept;
434constexpr bool operator> (const year_month& x, const year_month& y) noexcept;
435constexpr bool operator<=(const year_month& x, const year_month& y) noexcept;
436constexpr bool operator>=(const year_month& x, const year_month& y) noexcept;
437
438constexpr year_month operator+(const year_month& ym, const months& dm) noexcept;
439constexpr year_month operator+(const months& dm, const year_month& ym) noexcept;
440constexpr year_month operator-(const year_month& ym, const months& dm) noexcept;
441constexpr months operator-(const year_month& x, const year_month& y) noexcept;
442constexpr year_month operator+(const year_month& ym, const years& dy) noexcept;
443constexpr year_month operator+(const years& dy, const year_month& ym) noexcept;
444constexpr year_month operator-(const year_month& ym, const years& dy) noexcept;
445
446// 25.8.14, class year_month_day class // C++20
447year_month_day;
448
449constexpr bool operator==(const year_month_day& x, const year_month_day& y) noexcept;
450constexpr bool operator!=(const year_month_day& x, const year_month_day& y) noexcept;
451constexpr bool operator< (const year_month_day& x, const year_month_day& y) noexcept;
452constexpr bool operator> (const year_month_day& x, const year_month_day& y) noexcept;
453constexpr bool operator<=(const year_month_day& x, const year_month_day& y) noexcept;
454constexpr bool operator>=(const year_month_day& x, const year_month_day& y) noexcept;
455
456constexpr year_month_day operator+(const year_month_day& ymd, const months& dm) noexcept;
457constexpr year_month_day operator+(const months& dm, const year_month_day& ymd) noexcept;
458constexpr year_month_day operator+(const year_month_day& ymd, const years& dy) noexcept;
459constexpr year_month_day operator+(const years& dy, const year_month_day& ymd) noexcept;
460constexpr year_month_day operator-(const year_month_day& ymd, const months& dm) noexcept;
461constexpr year_month_day operator-(const year_month_day& ymd, const years& dy) noexcept;
462
463
464// 25.8.15, class year_month_day_last // C++20
465class year_month_day_last;
466
467constexpr bool operator==(const year_month_day_last& x,
468 const year_month_day_last& y) noexcept;
469constexpr bool operator!=(const year_month_day_last& x,
470 const year_month_day_last& y) noexcept;
471constexpr bool operator< (const year_month_day_last& x,
472 const year_month_day_last& y) noexcept;
473constexpr bool operator> (const year_month_day_last& x,
474 const year_month_day_last& y) noexcept;
475constexpr bool operator<=(const year_month_day_last& x,
476 const year_month_day_last& y) noexcept;
477constexpr bool operator>=(const year_month_day_last& x,
478 const year_month_day_last& y) noexcept;
479
480constexpr year_month_day_last
481 operator+(const year_month_day_last& ymdl, const months& dm) noexcept;
482constexpr year_month_day_last
483 operator+(const months& dm, const year_month_day_last& ymdl) noexcept;
484constexpr year_month_day_last
485 operator+(const year_month_day_last& ymdl, const years& dy) noexcept;
486constexpr year_month_day_last
487 operator+(const years& dy, const year_month_day_last& ymdl) noexcept;
488constexpr year_month_day_last
489 operator-(const year_month_day_last& ymdl, const months& dm) noexcept;
490constexpr year_month_day_last
491 operator-(const year_month_day_last& ymdl, const years& dy) noexcept;
492
493// 25.8.16, class year_month_weekday // C++20
494class year_month_weekday;
495
496constexpr bool operator==(const year_month_weekday& x,
497 const year_month_weekday& y) noexcept;
498constexpr bool operator!=(const year_month_weekday& x,
499 const year_month_weekday& y) noexcept;
500
501constexpr year_month_weekday
502 operator+(const year_month_weekday& ymwd, const months& dm) noexcept;
503constexpr year_month_weekday
504 operator+(const months& dm, const year_month_weekday& ymwd) noexcept;
505constexpr year_month_weekday
506 operator+(const year_month_weekday& ymwd, const years& dy) noexcept;
507constexpr year_month_weekday
508 operator+(const years& dy, const year_month_weekday& ymwd) noexcept;
509constexpr year_month_weekday
510 operator-(const year_month_weekday& ymwd, const months& dm) noexcept;
511constexpr year_month_weekday
512 operator-(const year_month_weekday& ymwd, const years& dy) noexcept;
513
514// 25.8.17, class year_month_weekday_last // C++20
515class year_month_weekday_last;
516
517constexpr bool operator==(const year_month_weekday_last& x,
518 const year_month_weekday_last& y) noexcept;
519constexpr bool operator!=(const year_month_weekday_last& x,
520 const year_month_weekday_last& y) noexcept;
521constexpr year_month_weekday_last
522 operator+(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
523constexpr year_month_weekday_last
524 operator+(const months& dm, const year_month_weekday_last& ymwdl) noexcept;
525constexpr year_month_weekday_last
526 operator+(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
527constexpr year_month_weekday_last
528 operator+(const years& dy, const year_month_weekday_last& ymwdl) noexcept;
529constexpr year_month_weekday_last
530 operator-(const year_month_weekday_last& ymwdl, const months& dm) noexcept;
531constexpr year_month_weekday_last
532 operator-(const year_month_weekday_last& ymwdl, const years& dy) noexcept;
Louis Dionne44bcff92018-08-03 22:36:53 +0000533
Marshall Clow40ca0c12018-07-18 17:37:51 +0000534// 25.8.18, civil calendar conventional syntax operators // C++20
535constexpr year_month
536 operator/(const year& y, const month& m) noexcept;
537constexpr year_month
538 operator/(const year& y, int m) noexcept;
539constexpr month_day
540 operator/(const month& m, const day& d) noexcept;
541constexpr month_day
542 operator/(const month& m, int d) noexcept;
543constexpr month_day
544 operator/(int m, const day& d) noexcept;
545constexpr month_day
546 operator/(const day& d, const month& m) noexcept;
547constexpr month_day
548 operator/(const day& d, int m) noexcept;
549constexpr month_day_last
550 operator/(const month& m, last_spec) noexcept;
551constexpr month_day_last
552 operator/(int m, last_spec) noexcept;
553constexpr month_day_last
554 operator/(last_spec, const month& m) noexcept;
555constexpr month_day_last
556 operator/(last_spec, int m) noexcept;
557constexpr month_weekday
558 operator/(const month& m, const weekday_indexed& wdi) noexcept;
559constexpr month_weekday
560 operator/(int m, const weekday_indexed& wdi) noexcept;
561constexpr month_weekday
562 operator/(const weekday_indexed& wdi, const month& m) noexcept;
563constexpr month_weekday
564 operator/(const weekday_indexed& wdi, int m) noexcept;
565constexpr month_weekday_last
566 operator/(const month& m, const weekday_last& wdl) noexcept;
567constexpr month_weekday_last
568 operator/(int m, const weekday_last& wdl) noexcept;
569constexpr month_weekday_last
570 operator/(const weekday_last& wdl, const month& m) noexcept;
571constexpr month_weekday_last
572 operator/(const weekday_last& wdl, int m) noexcept;
573constexpr year_month_day
574 operator/(const year_month& ym, const day& d) noexcept;
575constexpr year_month_day
576 operator/(const year_month& ym, int d) noexcept;
577constexpr year_month_day
578 operator/(const year& y, const month_day& md) noexcept;
579constexpr year_month_day
580 operator/(int y, const month_day& md) noexcept;
581constexpr year_month_day
582 operator/(const month_day& md, const year& y) noexcept;
583constexpr year_month_day
584 operator/(const month_day& md, int y) noexcept;
585constexpr year_month_day_last
586 operator/(const year_month& ym, last_spec) noexcept;
587constexpr year_month_day_last
588 operator/(const year& y, const month_day_last& mdl) noexcept;
589constexpr year_month_day_last
590 operator/(int y, const month_day_last& mdl) noexcept;
591constexpr year_month_day_last
592 operator/(const month_day_last& mdl, const year& y) noexcept;
593constexpr year_month_day_last
594 operator/(const month_day_last& mdl, int y) noexcept;
595constexpr year_month_weekday
596 operator/(const year_month& ym, const weekday_indexed& wdi) noexcept;
597constexpr year_month_weekday
598 operator/(const year& y, const month_weekday& mwd) noexcept;
599constexpr year_month_weekday
600 operator/(int y, const month_weekday& mwd) noexcept;
601constexpr year_month_weekday
602 operator/(const month_weekday& mwd, const year& y) noexcept;
603constexpr year_month_weekday
604 operator/(const month_weekday& mwd, int y) noexcept;
605constexpr year_month_weekday_last
606 operator/(const year_month& ym, const weekday_last& wdl) noexcept;
607constexpr year_month_weekday_last
608 operator/(const year& y, const month_weekday_last& mwdl) noexcept;
609constexpr year_month_weekday_last
610 operator/(int y, const month_weekday_last& mwdl) noexcept;
611constexpr year_month_weekday_last
612 operator/(const month_weekday_last& mwdl, const year& y) noexcept;
613constexpr year_month_weekday_last
Louis Dionne44bcff92018-08-03 22:36:53 +0000614 operator/(const month_weekday_last& mwdl, int y) noexcept;
Marshall Clow40ca0c12018-07-18 17:37:51 +0000615
616// 25.9, class template time_of_day // C++20
617template<class Duration> class time_of_day;
618
619template<> class time_of_day<hours>;
620template<> class time_of_day<minutes>;
621template<> class time_of_day<seconds>;
622template<class Rep, class Period> class time_of_day<duration<Rep, Period>>;
623
624// 25.10.2, time zone database // C++20
625struct tzdb;
626class tzdb_list;
627
628// 25.10.2.3, time zone database access // C++20
629const tzdb& get_tzdb();
630tzdb_list& get_tzdb_list();
631const time_zone* locate_zone(string_view tz_name);
632const time_zone* current_zone();
633
634// 25.10.2.4, remote time zone database support // C++20
635const tzdb& reload_tzdb();
636string remote_version();
637
638// 25.10.3, exception classes // C++20
639class nonexistent_local_time;
640class ambiguous_local_time;
641
642// 25.10.4, information classes // C++20
643struct sys_info;
644struct local_info;
Louis Dionne44bcff92018-08-03 22:36:53 +0000645
Marshall Clow40ca0c12018-07-18 17:37:51 +0000646// 25.10.5, class time_zone // C++20
647enum class choose {earliest, latest};
648class time_zone;
649bool operator==(const time_zone& x, const time_zone& y) noexcept;
650bool operator!=(const time_zone& x, const time_zone& y) noexcept;
651bool operator<(const time_zone& x, const time_zone& y) noexcept;
652bool operator>(const time_zone& x, const time_zone& y) noexcept;
653bool operator<=(const time_zone& x, const time_zone& y) noexcept;
654bool operator>=(const time_zone& x, const time_zone& y) noexcept;
Louis Dionne44bcff92018-08-03 22:36:53 +0000655
Marshall Clow40ca0c12018-07-18 17:37:51 +0000656// 25.10.6, class template zoned_traits // C++20
657template<class T> struct zoned_traits;
658
659// 25.10.7, class template zoned_time // C++20
660template<class Duration, class TimeZonePtr = const time_zone*> class zoned_time;
661using zoned_seconds = zoned_time<seconds>;
662
663template<class Duration1, class Duration2, class TimeZonePtr>
664 bool operator==(const zoned_time<Duration1, TimeZonePtr>& x,
665 const zoned_time<Duration2, TimeZonePtr>& y);
666template<class Duration1, class Duration2, class TimeZonePtr>
667 bool operator!=(const zoned_time<Duration1, TimeZonePtr>& x,
668 const zoned_time<Duration2, TimeZonePtr>& y);
669
670// 25.10.8, leap second support // C++20
671class leap;
672
673bool operator==(const leap& x, const leap& y);
674bool operator!=(const leap& x, const leap& y);
675bool operator< (const leap& x, const leap& y);
676bool operator> (const leap& x, const leap& y);
677bool operator<=(const leap& x, const leap& y);
678bool operator>=(const leap& x, const leap& y);
679template<class Duration>
680 bool operator==(const leap& x, const sys_time<Duration>& y);
681template<class Duration>
682 bool operator==(const sys_time<Duration>& x, const leap& y);
683template<class Duration>
684 bool operator!=(const leap& x, const sys_time<Duration>& y);
685template<class Duration>
686 bool operator!=(const sys_time<Duration>& x, const leap& y);
687template<class Duration>
688 bool operator< (const leap& x, const sys_time<Duration>& y);
689template<class Duration>
690 bool operator< (const sys_time<Duration>& x, const leap& y);
691template<class Duration>
692 bool operator> (const leap& x, const sys_time<Duration>& y);
693template<class Duration>
694 bool operator> (const sys_time<Duration>& x, const leap& y);
695template<class Duration>
696 bool operator<=(const leap& x, const sys_time<Duration>& y);
697template<class Duration>
698 bool operator<=(const sys_time<Duration>& x, const leap& y);
699template<class Duration>
700 bool operator>=(const leap& x, const sys_time<Duration>& y);
701template<class Duration>
702 bool operator>=(const sys_time<Duration>& x, const leap& y);
703
704// 25.10.9, class link // C++20
705class link;
706bool operator==(const link& x, const link& y);
707bool operator!=(const link& x, const link& y);
708bool operator< (const link& x, const link& y);
709bool operator> (const link& x, const link& y);
710bool operator<=(const link& x, const link& y);
711bool operator>=(const link& x, const link& y);
712
713// 25.11, formatting // C++20
714template<class charT, class Streamable>
715 basic_string<charT>
716 format(const charT* fmt, const Streamable& s);
717
718template<class charT, class Streamable>
719 basic_string<charT>
720 format(const locale& loc, const charT* fmt, const Streamable& s);
721
722template<class charT, class traits, class Alloc, class Streamable>
723 basic_string<charT, traits, Alloc>
724 format(const basic_string<charT, traits, Alloc>& fmt, const Streamable& s);
725
726template<class charT, class traits, class Alloc, class Streamable>
727 basic_string<charT, traits, Alloc>
728 format(const locale& loc, const basic_string<charT, traits, Alloc>& fmt,
Louis Dionne44bcff92018-08-03 22:36:53 +0000729 const Streamable& s);
Marshall Clow40ca0c12018-07-18 17:37:51 +0000730
731// 25.12, parsing // C++20
732template<class charT, class traits, class Alloc, class Parsable>
733unspecified
734 parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp);
735
736template<class charT, class traits, class Alloc, class Parsable>
737unspecified
738 parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
739 basic_string<charT, traits, Alloc>& abbrev);
740
741template<class charT, class traits, class Alloc, class Parsable>
742unspecified
743 parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
744 minutes& offset);
745
746template<class charT, class traits, class Alloc, class Parsable>
747unspecified
748 parse(const basic_string<charT, traits, Alloc>& format, Parsable& tp,
749 basic_string<charT, traits, Alloc>& abbrev, minutes& offset);
750
Marshall Clow26058352018-10-16 17:27:54 +0000751// calendrical constants
Louis Dionne44bcff92018-08-03 22:36:53 +0000752inline constexpr last_spec last{}; // C++20
Marshall Clow40ca0c12018-07-18 17:37:51 +0000753inline constexpr chrono::weekday Sunday{0}; // C++20
754inline constexpr chrono::weekday Monday{1}; // C++20
755inline constexpr chrono::weekday Tuesday{2}; // C++20
756inline constexpr chrono::weekday Wednesday{3}; // C++20
757inline constexpr chrono::weekday Thursday{4}; // C++20
758inline constexpr chrono::weekday Friday{5}; // C++20
759inline constexpr chrono::weekday Saturday{6}; // C++20
760
761inline constexpr chrono::month January{1}; // C++20
762inline constexpr chrono::month February{2}; // C++20
763inline constexpr chrono::month March{3}; // C++20
764inline constexpr chrono::month April{4}; // C++20
765inline constexpr chrono::month May{5}; // C++20
766inline constexpr chrono::month June{6}; // C++20
767inline constexpr chrono::month July{7}; // C++20
768inline constexpr chrono::month August{8}; // C++20
769inline constexpr chrono::month September{9}; // C++20
770inline constexpr chrono::month October{10}; // C++20
771inline constexpr chrono::month November{11}; // C++20
772inline constexpr chrono::month December{12}; // C++20
Howard Hinnantc51e1022010-05-11 19:42:16 +0000773} // chrono
774
Marshall Clow40ca0c12018-07-18 17:37:51 +0000775inline namespace literals {
776 inline namespace chrono_literals {
Marshall Clow2ac805a2017-08-09 15:42:50 +0000777constexpr chrono::hours operator ""h(unsigned long long); // C++14
778constexpr chrono::duration<unspecified , ratio<3600,1>> operator ""h(long double); // C++14
779constexpr chrono::minutes operator ""min(unsigned long long); // C++14
780constexpr chrono::duration<unspecified , ratio<60,1>> operator ""min(long double); // C++14
781constexpr chrono::seconds operator ""s(unsigned long long); // C++14
782constexpr chrono::duration<unspecified > operator ""s(long double); // C++14
783constexpr chrono::milliseconds operator ""ms(unsigned long long); // C++14
784constexpr chrono::duration<unspecified , milli> operator ""ms(long double); // C++14
785constexpr chrono::microseconds operator ""us(unsigned long long); // C++14
786constexpr chrono::duration<unspecified , micro> operator ""us(long double); // C++14
787constexpr chrono::nanoseconds operator ""ns(unsigned long long); // C++14
788constexpr chrono::duration<unspecified , nano> operator ""ns(long double); // C++14
Marshall Clow40ca0c12018-07-18 17:37:51 +0000789constexpr chrono::day operator ""d(unsigned long long d) noexcept; // C++20
790constexpr chrono::year operator ""y(unsigned long long y) noexcept; // C++20
791} // chrono_literals
792} // literals
Marshall Cloweb41e5c2013-07-24 21:18:14 +0000793
Howard Hinnantc51e1022010-05-11 19:42:16 +0000794} // std
795*/
796
797#include <__config>
798#include <ctime>
799#include <type_traits>
800#include <ratio>
801#include <limits>
Marshall Clow0a1e7502018-09-12 19:41:40 +0000802#include <version>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000803
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000804#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
Howard Hinnantc51e1022010-05-11 19:42:16 +0000805#pragma GCC system_header
Howard Hinnantaaaa52b2011-10-17 20:05:10 +0000806#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +0000807
Eric Fiselierf4433a32017-05-31 22:07:49 +0000808_LIBCPP_PUSH_MACROS
809#include <__undef_macros>
810
Eric Fiselier4dcc2542018-12-21 04:30:04 +0000811#ifndef _LIBCPP_CXX03_LANG
Eric Fiselier049273c2018-12-21 03:54:57 +0000812_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
813struct _FilesystemClock;
814_LIBCPP_END_NAMESPACE_FILESYSTEM
Eric Fiselier4dcc2542018-12-21 04:30:04 +0000815#endif // !_LIBCPP_CXX03_LANG
Eric Fiselierf4433a32017-05-31 22:07:49 +0000816
Howard Hinnantc51e1022010-05-11 19:42:16 +0000817_LIBCPP_BEGIN_NAMESPACE_STD
818
819namespace chrono
820{
821
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000822template <class _Rep, class _Period = ratio<1> > class _LIBCPP_TEMPLATE_VIS duration;
Howard Hinnantc51e1022010-05-11 19:42:16 +0000823
Howard Hinnantf39463b2010-05-18 17:32:30 +0000824template <class _Tp>
Howard Hinnantc51e1022010-05-11 19:42:16 +0000825struct __is_duration : false_type {};
826
827template <class _Rep, class _Period>
828struct __is_duration<duration<_Rep, _Period> > : true_type {};
829
830template <class _Rep, class _Period>
831struct __is_duration<const duration<_Rep, _Period> > : true_type {};
832
833template <class _Rep, class _Period>
834struct __is_duration<volatile duration<_Rep, _Period> > : true_type {};
835
836template <class _Rep, class _Period>
837struct __is_duration<const volatile duration<_Rep, _Period> > : true_type {};
838
839} // chrono
840
841template <class _Rep1, class _Period1, class _Rep2, class _Period2>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000842struct _LIBCPP_TEMPLATE_VIS common_type<chrono::duration<_Rep1, _Period1>,
Howard Hinnanta37d3cf2013-08-12 18:38:34 +0000843 chrono::duration<_Rep2, _Period2> >
Howard Hinnantc51e1022010-05-11 19:42:16 +0000844{
845 typedef chrono::duration<typename common_type<_Rep1, _Rep2>::type,
846 typename __ratio_gcd<_Period1, _Period2>::type> type;
847};
848
849namespace chrono {
850
851// duration_cast
852
853template <class _FromDuration, class _ToDuration,
854 class _Period = typename ratio_divide<typename _FromDuration::period, typename _ToDuration::period>::type,
855 bool = _Period::num == 1,
856 bool = _Period::den == 1>
857struct __duration_cast;
858
859template <class _FromDuration, class _ToDuration, class _Period>
860struct __duration_cast<_FromDuration, _ToDuration, _Period, true, true>
861{
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000862 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +0000863 _ToDuration operator()(const _FromDuration& __fd) const
864 {
865 return _ToDuration(static_cast<typename _ToDuration::rep>(__fd.count()));
866 }
867};
868
869template <class _FromDuration, class _ToDuration, class _Period>
870struct __duration_cast<_FromDuration, _ToDuration, _Period, true, false>
871{
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000872 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +0000873 _ToDuration operator()(const _FromDuration& __fd) const
874 {
875 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
876 return _ToDuration(static_cast<typename _ToDuration::rep>(
877 static_cast<_Ct>(__fd.count()) / static_cast<_Ct>(_Period::den)));
878 }
879};
880
881template <class _FromDuration, class _ToDuration, class _Period>
882struct __duration_cast<_FromDuration, _ToDuration, _Period, false, true>
883{
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000884 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +0000885 _ToDuration operator()(const _FromDuration& __fd) const
886 {
887 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
888 return _ToDuration(static_cast<typename _ToDuration::rep>(
889 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)));
890 }
891};
892
893template <class _FromDuration, class _ToDuration, class _Period>
894struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false>
895{
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000896 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +0000897 _ToDuration operator()(const _FromDuration& __fd) const
898 {
899 typedef typename common_type<typename _ToDuration::rep, typename _FromDuration::rep, intmax_t>::type _Ct;
900 return _ToDuration(static_cast<typename _ToDuration::rep>(
901 static_cast<_Ct>(__fd.count()) * static_cast<_Ct>(_Period::num)
902 / static_cast<_Ct>(_Period::den)));
903 }
904};
905
906template <class _ToDuration, class _Rep, class _Period>
907inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +0000908_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +0000909typename enable_if
910<
911 __is_duration<_ToDuration>::value,
912 _ToDuration
913>::type
914duration_cast(const duration<_Rep, _Period>& __fd)
915{
916 return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
917}
918
Howard Hinnant874ad9a2010-09-21 21:28:23 +0000919template <class _Rep>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000920struct _LIBCPP_TEMPLATE_VIS treat_as_floating_point : is_floating_point<_Rep> {};
Howard Hinnantc51e1022010-05-11 19:42:16 +0000921
Marshall Clow59581f02015-11-30 05:39:30 +0000922#if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
Marshall Clowf1bf62f2018-01-02 17:17:01 +0000923template <class _Rep>
924_LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool treat_as_floating_point_v
Marshall Clow59581f02015-11-30 05:39:30 +0000925 = treat_as_floating_point<_Rep>::value;
926#endif
927
Howard Hinnantc51e1022010-05-11 19:42:16 +0000928template <class _Rep>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000929struct _LIBCPP_TEMPLATE_VIS duration_values
Howard Hinnantc51e1022010-05-11 19:42:16 +0000930{
931public:
Marshall Clowb1296bd2018-11-13 17:22:41 +0000932 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT {return _Rep(0);}
933 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep max() _NOEXCEPT {return numeric_limits<_Rep>::max();}
934 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR _Rep min() _NOEXCEPT {return numeric_limits<_Rep>::lowest();}
Howard Hinnantc51e1022010-05-11 19:42:16 +0000935};
936
Marshall Clowf2eabaf2015-11-05 19:33:59 +0000937#if _LIBCPP_STD_VER > 14
938template <class _ToDuration, class _Rep, class _Period>
939inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
940typename enable_if
941<
942 __is_duration<_ToDuration>::value,
943 _ToDuration
944>::type
945floor(const duration<_Rep, _Period>& __d)
946{
947 _ToDuration __t = duration_cast<_ToDuration>(__d);
948 if (__t > __d)
949 __t = __t - _ToDuration{1};
950 return __t;
951}
952
953template <class _ToDuration, class _Rep, class _Period>
954inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
955typename enable_if
956<
957 __is_duration<_ToDuration>::value,
958 _ToDuration
959>::type
960ceil(const duration<_Rep, _Period>& __d)
961{
962 _ToDuration __t = duration_cast<_ToDuration>(__d);
963 if (__t < __d)
964 __t = __t + _ToDuration{1};
965 return __t;
966}
967
968template <class _ToDuration, class _Rep, class _Period>
969inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
970typename enable_if
971<
972 __is_duration<_ToDuration>::value,
973 _ToDuration
974>::type
975round(const duration<_Rep, _Period>& __d)
976{
977 _ToDuration __lower = floor<_ToDuration>(__d);
978 _ToDuration __upper = __lower + _ToDuration{1};
979 auto __lowerDiff = __d - __lower;
980 auto __upperDiff = __upper - __d;
981 if (__lowerDiff < __upperDiff)
982 return __lower;
983 if (__lowerDiff > __upperDiff)
984 return __upper;
985 return __lower.count() & 1 ? __upper : __lower;
986}
987#endif
988
Howard Hinnantc51e1022010-05-11 19:42:16 +0000989// duration
990
991template <class _Rep, class _Period>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +0000992class _LIBCPP_TEMPLATE_VIS duration
Howard Hinnantc51e1022010-05-11 19:42:16 +0000993{
994 static_assert(!__is_duration<_Rep>::value, "A duration representation can not be a duration");
995 static_assert(__is_ratio<_Period>::value, "Second template parameter of duration must be a std::ratio");
996 static_assert(_Period::num > 0, "duration period must be positive");
Howard Hinnant0a51e152013-08-31 16:51:56 +0000997
998 template <class _R1, class _R2>
999 struct __no_overflow
1000 {
1001 private:
1002 static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
1003 static const intmax_t __gcd_d1_d2 = __static_gcd<_R1::den, _R2::den>::value;
1004 static const intmax_t __n1 = _R1::num / __gcd_n1_n2;
1005 static const intmax_t __d1 = _R1::den / __gcd_d1_d2;
1006 static const intmax_t __n2 = _R2::num / __gcd_n1_n2;
1007 static const intmax_t __d2 = _R2::den / __gcd_d1_d2;
1008 static const intmax_t max = -((intmax_t(1) << (sizeof(intmax_t) * CHAR_BIT - 1)) + 1);
1009
1010 template <intmax_t _Xp, intmax_t _Yp, bool __overflow>
1011 struct __mul // __overflow == false
1012 {
1013 static const intmax_t value = _Xp * _Yp;
1014 };
1015
1016 template <intmax_t _Xp, intmax_t _Yp>
1017 struct __mul<_Xp, _Yp, true>
1018 {
1019 static const intmax_t value = 1;
1020 };
1021
1022 public:
1023 static const bool value = (__n1 <= max / __d2) && (__n2 <= max / __d1);
1024 typedef ratio<__mul<__n1, __d2, !value>::value,
1025 __mul<__n2, __d1, !value>::value> type;
1026 };
Louis Dionne44bcff92018-08-03 22:36:53 +00001027
Howard Hinnantc51e1022010-05-11 19:42:16 +00001028public:
1029 typedef _Rep rep;
Marshall Clow76200b22017-03-21 18:38:57 +00001030 typedef typename _Period::type period;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001031private:
1032 rep __rep_;
1033public:
1034
Marshall Clow5c459c92013-07-31 19:32:19 +00001035 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Eric Fiselier07b2b552016-11-18 06:42:17 +00001036#ifndef _LIBCPP_CXX03_LANG
Marshall Clow5c459c92013-07-31 19:32:19 +00001037 duration() = default;
Marshall Clow3dbcf132013-07-31 19:39:37 +00001038#else
1039 duration() {}
Marshall Clow5c459c92013-07-31 19:32:19 +00001040#endif
1041
Howard Hinnantc51e1022010-05-11 19:42:16 +00001042 template <class _Rep2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001043 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001044 explicit duration(const _Rep2& __r,
1045 typename enable_if
1046 <
1047 is_convertible<_Rep2, rep>::value &&
1048 (treat_as_floating_point<rep>::value ||
1049 !treat_as_floating_point<_Rep2>::value)
1050 >::type* = 0)
1051 : __rep_(__r) {}
1052
1053 // conversions
1054 template <class _Rep2, class _Period2>
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001055 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001056 duration(const duration<_Rep2, _Period2>& __d,
1057 typename enable_if
1058 <
Howard Hinnant0a51e152013-08-31 16:51:56 +00001059 __no_overflow<_Period2, period>::value && (
Howard Hinnantc51e1022010-05-11 19:42:16 +00001060 treat_as_floating_point<rep>::value ||
Howard Hinnant0a51e152013-08-31 16:51:56 +00001061 (__no_overflow<_Period2, period>::type::den == 1 &&
1062 !treat_as_floating_point<_Rep2>::value))
Howard Hinnantc51e1022010-05-11 19:42:16 +00001063 >::type* = 0)
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001064 : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001065
1066 // observer
1067
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001068 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR rep count() const {return __rep_;}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001069
1070 // arithmetic
1071
Marshall Clow76200b22017-03-21 18:38:57 +00001072 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {return typename common_type<duration>::type(*this);}
1073 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {return typename common_type<duration>::type(-__rep_);}
Marshall Clow5c87ad02017-01-04 23:03:24 +00001074 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator++() {++__rep_; return *this;}
1075 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator++(int) {return duration(__rep_++);}
1076 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator--() {--__rep_; return *this;}
1077 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration operator--(int) {return duration(__rep_--);}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001078
Marshall Clow5c87ad02017-01-04 23:03:24 +00001079 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator+=(const duration& __d) {__rep_ += __d.count(); return *this;}
1080 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator-=(const duration& __d) {__rep_ -= __d.count(); return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001081
Marshall Clow5c87ad02017-01-04 23:03:24 +00001082 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator*=(const rep& rhs) {__rep_ *= rhs; return *this;}
1083 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator/=(const rep& rhs) {__rep_ /= rhs; return *this;}
1084 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const rep& rhs) {__rep_ %= rhs; return *this;}
1085 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 duration& operator%=(const duration& rhs) {__rep_ %= rhs.count(); return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001086
1087 // special values
1088
Marshall Clowb1296bd2018-11-13 17:22:41 +00001089 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {return duration(duration_values<rep>::zero());}
1090 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration min() _NOEXCEPT {return duration(duration_values<rep>::min());}
1091 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR duration max() _NOEXCEPT {return duration(duration_values<rep>::max());}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001092};
1093
1094typedef duration<long long, nano> nanoseconds;
1095typedef duration<long long, micro> microseconds;
1096typedef duration<long long, milli> milliseconds;
1097typedef duration<long long > seconds;
1098typedef duration< long, ratio< 60> > minutes;
1099typedef duration< long, ratio<3600> > hours;
Marshall Clow26058352018-10-16 17:27:54 +00001100#if _LIBCPP_STD_VER > 17
1101typedef duration< int, ratio_multiply<ratio<24>, hours::period>> days;
1102typedef duration< int, ratio_multiply<ratio<7>, days::period>> weeks;
1103typedef duration< int, ratio_multiply<ratio<146097, 400>, days::period>> years;
1104typedef duration< int, ratio_divide<years::period, ratio<12>>> months;
1105#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001106// Duration ==
1107
1108template <class _LhsDuration, class _RhsDuration>
1109struct __duration_eq
1110{
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001111 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnant12967fb2013-06-28 18:09:35 +00001112 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
Howard Hinnantc51e1022010-05-11 19:42:16 +00001113 {
1114 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
1115 return _Ct(__lhs).count() == _Ct(__rhs).count();
1116 }
1117};
1118
1119template <class _LhsDuration>
1120struct __duration_eq<_LhsDuration, _LhsDuration>
1121{
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001122 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnant12967fb2013-06-28 18:09:35 +00001123 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
Howard Hinnantc51e1022010-05-11 19:42:16 +00001124 {return __lhs.count() == __rhs.count();}
1125};
1126
1127template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1128inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001129_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001130bool
1131operator==(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1132{
1133 return __duration_eq<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
1134}
1135
1136// Duration !=
1137
1138template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1139inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001140_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001141bool
1142operator!=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1143{
1144 return !(__lhs == __rhs);
1145}
1146
1147// Duration <
1148
1149template <class _LhsDuration, class _RhsDuration>
1150struct __duration_lt
1151{
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001152 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnant12967fb2013-06-28 18:09:35 +00001153 bool operator()(const _LhsDuration& __lhs, const _RhsDuration& __rhs) const
Howard Hinnantc51e1022010-05-11 19:42:16 +00001154 {
1155 typedef typename common_type<_LhsDuration, _RhsDuration>::type _Ct;
1156 return _Ct(__lhs).count() < _Ct(__rhs).count();
1157 }
1158};
1159
1160template <class _LhsDuration>
1161struct __duration_lt<_LhsDuration, _LhsDuration>
1162{
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001163 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
Howard Hinnant12967fb2013-06-28 18:09:35 +00001164 bool operator()(const _LhsDuration& __lhs, const _LhsDuration& __rhs) const
Howard Hinnantc51e1022010-05-11 19:42:16 +00001165 {return __lhs.count() < __rhs.count();}
1166};
1167
1168template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1169inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001170_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001171bool
1172operator< (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1173{
1174 return __duration_lt<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >()(__lhs, __rhs);
1175}
1176
1177// Duration >
1178
1179template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1180inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001181_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001182bool
1183operator> (const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1184{
1185 return __rhs < __lhs;
1186}
1187
1188// Duration <=
1189
1190template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1191inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001192_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001193bool
1194operator<=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1195{
1196 return !(__rhs < __lhs);
1197}
1198
1199// Duration >=
1200
1201template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1202inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001203_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001204bool
1205operator>=(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1206{
1207 return !(__lhs < __rhs);
1208}
1209
1210// Duration +
1211
1212template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1213inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001214_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001215typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
1216operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1217{
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001218 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
1219 return _Cd(_Cd(__lhs).count() + _Cd(__rhs).count());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001220}
1221
1222// Duration -
1223
1224template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1225inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001226_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001227typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
1228operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1229{
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001230 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
1231 return _Cd(_Cd(__lhs).count() - _Cd(__rhs).count());
Howard Hinnantc51e1022010-05-11 19:42:16 +00001232}
1233
1234// Duration *
1235
1236template <class _Rep1, class _Period, class _Rep2>
1237inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001238_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001239typename enable_if
1240<
1241 is_convertible<_Rep2, typename common_type<_Rep1, _Rep2>::type>::value,
1242 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
1243>::type
1244operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
1245{
1246 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001247 typedef duration<_Cr, _Period> _Cd;
1248 return _Cd(_Cd(__d).count() * static_cast<_Cr>(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001249}
1250
1251template <class _Rep1, class _Period, class _Rep2>
1252inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001253_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001254typename enable_if
1255<
1256 is_convertible<_Rep1, typename common_type<_Rep1, _Rep2>::type>::value,
1257 duration<typename common_type<_Rep1, _Rep2>::type, _Period>
1258>::type
1259operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
1260{
1261 return __d * __s;
1262}
1263
1264// Duration /
1265
1266template <class _Duration, class _Rep, bool = __is_duration<_Rep>::value>
1267struct __duration_divide_result
1268{
1269};
1270
1271template <class _Duration, class _Rep2,
1272 bool = is_convertible<_Rep2,
1273 typename common_type<typename _Duration::rep, _Rep2>::type>::value>
1274struct __duration_divide_imp
1275{
1276};
1277
1278template <class _Rep1, class _Period, class _Rep2>
1279struct __duration_divide_imp<duration<_Rep1, _Period>, _Rep2, true>
1280{
1281 typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period> type;
1282};
1283
1284template <class _Rep1, class _Period, class _Rep2>
1285struct __duration_divide_result<duration<_Rep1, _Period>, _Rep2, false>
1286 : __duration_divide_imp<duration<_Rep1, _Period>, _Rep2>
1287{
1288};
1289
1290template <class _Rep1, class _Period, class _Rep2>
1291inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001292_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001293typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
1294operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
1295{
1296 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001297 typedef duration<_Cr, _Period> _Cd;
1298 return _Cd(_Cd(__d).count() / static_cast<_Cr>(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001299}
1300
1301template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1302inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001303_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001304typename common_type<_Rep1, _Rep2>::type
1305operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1306{
1307 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
1308 return _Ct(__lhs).count() / _Ct(__rhs).count();
1309}
1310
1311// Duration %
1312
1313template <class _Rep1, class _Period, class _Rep2>
1314inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001315_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001316typename __duration_divide_result<duration<_Rep1, _Period>, _Rep2>::type
1317operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
1318{
1319 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001320 typedef duration<_Cr, _Period> _Cd;
1321 return _Cd(_Cd(__d).count() % static_cast<_Cr>(__s));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001322}
1323
1324template <class _Rep1, class _Period1, class _Rep2, class _Period2>
1325inline _LIBCPP_INLINE_VISIBILITY
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001326_LIBCPP_CONSTEXPR
Howard Hinnantc51e1022010-05-11 19:42:16 +00001327typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
1328operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1329{
Howard Hinnantcf3143c2012-07-13 19:17:27 +00001330 typedef typename common_type<_Rep1, _Rep2>::type _Cr;
1331 typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
1332 return _Cd(static_cast<_Cr>(_Cd(__lhs).count()) % static_cast<_Cr>(_Cd(__rhs).count()));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001333}
1334
1335//////////////////////////////////////////////////////////
1336///////////////////// time_point /////////////////////////
1337//////////////////////////////////////////////////////////
1338
1339template <class _Clock, class _Duration = typename _Clock::duration>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001340class _LIBCPP_TEMPLATE_VIS time_point
Howard Hinnantc51e1022010-05-11 19:42:16 +00001341{
1342 static_assert(__is_duration<_Duration>::value,
1343 "Second template parameter of time_point must be a std::chrono::duration");
1344public:
1345 typedef _Clock clock;
1346 typedef _Duration duration;
1347 typedef typename duration::rep rep;
1348 typedef typename duration::period period;
1349private:
1350 duration __d_;
1351
1352public:
Marshall Clow5c459c92013-07-31 19:32:19 +00001353 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 time_point() : __d_(duration::zero()) {}
1354 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 explicit time_point(const duration& __d) : __d_(__d) {}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001355
1356 // conversions
1357 template <class _Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001358 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001359 time_point(const time_point<clock, _Duration2>& t,
1360 typename enable_if
1361 <
1362 is_convertible<_Duration2, duration>::value
1363 >::type* = 0)
1364 : __d_(t.time_since_epoch()) {}
1365
1366 // observer
1367
Marshall Clow5c459c92013-07-31 19:32:19 +00001368 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11 duration time_since_epoch() const {return __d_;}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001369
1370 // arithmetic
1371
Marshall Clowdf247eb2018-08-29 23:02:15 +00001372 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 time_point& operator+=(const duration& __d) {__d_ += __d; return *this;}
1373 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14 time_point& operator-=(const duration& __d) {__d_ -= __d; return *this;}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001374
1375 // special values
1376
Marshall Clowb1296bd2018-11-13 17:22:41 +00001377 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point min() _NOEXCEPT {return time_point(duration::min());}
1378 _LIBCPP_INLINE_VISIBILITY static _LIBCPP_CONSTEXPR time_point max() _NOEXCEPT {return time_point(duration::max());}
Howard Hinnantc51e1022010-05-11 19:42:16 +00001379};
1380
1381} // chrono
1382
1383template <class _Clock, class _Duration1, class _Duration2>
Eric Fiselierb5eb1bf2017-01-04 23:56:00 +00001384struct _LIBCPP_TEMPLATE_VIS common_type<chrono::time_point<_Clock, _Duration1>,
Howard Hinnanta37d3cf2013-08-12 18:38:34 +00001385 chrono::time_point<_Clock, _Duration2> >
Howard Hinnantc51e1022010-05-11 19:42:16 +00001386{
1387 typedef chrono::time_point<_Clock, typename common_type<_Duration1, _Duration2>::type> type;
1388};
1389
1390namespace chrono {
1391
1392template <class _ToDuration, class _Clock, class _Duration>
Marshall Clow5c459c92013-07-31 19:32:19 +00001393inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001394time_point<_Clock, _ToDuration>
1395time_point_cast(const time_point<_Clock, _Duration>& __t)
1396{
Howard Hinnantb1ad5a82011-06-30 21:18:19 +00001397 return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
Howard Hinnantc51e1022010-05-11 19:42:16 +00001398}
1399
Marshall Clowf2eabaf2015-11-05 19:33:59 +00001400#if _LIBCPP_STD_VER > 14
1401template <class _ToDuration, class _Clock, class _Duration>
1402inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
1403typename enable_if
1404<
1405 __is_duration<_ToDuration>::value,
1406 time_point<_Clock, _ToDuration>
1407>::type
1408floor(const time_point<_Clock, _Duration>& __t)
1409{
1410 return time_point<_Clock, _ToDuration>{floor<_ToDuration>(__t.time_since_epoch())};
1411}
1412
1413template <class _ToDuration, class _Clock, class _Duration>
1414inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
1415typename enable_if
1416<
1417 __is_duration<_ToDuration>::value,
1418 time_point<_Clock, _ToDuration>
1419>::type
1420ceil(const time_point<_Clock, _Duration>& __t)
1421{
1422 return time_point<_Clock, _ToDuration>{ceil<_ToDuration>(__t.time_since_epoch())};
1423}
1424
1425template <class _ToDuration, class _Clock, class _Duration>
1426inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
1427typename enable_if
1428<
1429 __is_duration<_ToDuration>::value,
1430 time_point<_Clock, _ToDuration>
1431>::type
1432round(const time_point<_Clock, _Duration>& __t)
1433{
1434 return time_point<_Clock, _ToDuration>{round<_ToDuration>(__t.time_since_epoch())};
1435}
1436
1437template <class _Rep, class _Period>
1438inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
1439typename enable_if
1440<
1441 numeric_limits<_Rep>::is_signed,
1442 duration<_Rep, _Period>
1443>::type
1444abs(duration<_Rep, _Period> __d)
1445{
1446 return __d >= __d.zero() ? __d : -__d;
1447}
1448#endif
1449
Howard Hinnantc51e1022010-05-11 19:42:16 +00001450// time_point ==
1451
1452template <class _Clock, class _Duration1, class _Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001453inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001454bool
1455operator==(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1456{
1457 return __lhs.time_since_epoch() == __rhs.time_since_epoch();
1458}
1459
1460// time_point !=
1461
1462template <class _Clock, class _Duration1, class _Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001463inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001464bool
1465operator!=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1466{
1467 return !(__lhs == __rhs);
1468}
1469
1470// time_point <
1471
1472template <class _Clock, class _Duration1, class _Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001473inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001474bool
1475operator<(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1476{
1477 return __lhs.time_since_epoch() < __rhs.time_since_epoch();
1478}
1479
1480// time_point >
1481
1482template <class _Clock, class _Duration1, class _Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001483inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001484bool
1485operator>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1486{
1487 return __rhs < __lhs;
1488}
1489
1490// time_point <=
1491
1492template <class _Clock, class _Duration1, class _Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001493inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001494bool
1495operator<=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1496{
1497 return !(__rhs < __lhs);
1498}
1499
1500// time_point >=
1501
1502template <class _Clock, class _Duration1, class _Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001503inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001504bool
1505operator>=(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1506{
1507 return !(__lhs < __rhs);
1508}
1509
1510// time_point operator+(time_point x, duration y);
1511
1512template <class _Clock, class _Duration1, class _Rep2, class _Period2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001513inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001514time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1515operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1516{
1517 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
Marshall Clow5c459c92013-07-31 19:32:19 +00001518 return _Tr (__lhs.time_since_epoch() + __rhs);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001519}
1520
1521// time_point operator+(duration x, time_point y);
1522
1523template <class _Rep1, class _Period1, class _Clock, class _Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001524inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001525time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
1526operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1527{
1528 return __rhs + __lhs;
1529}
1530
1531// time_point operator-(time_point x, duration y);
1532
1533template <class _Clock, class _Duration1, class _Rep2, class _Period2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001534inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001535time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
1536operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs)
1537{
Marshall Clow78dbe462016-11-14 18:22:19 +00001538 typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret;
1539 return _Ret(__lhs.time_since_epoch() -__rhs);
Howard Hinnantc51e1022010-05-11 19:42:16 +00001540}
1541
1542// duration operator-(time_point x, time_point y);
1543
1544template <class _Clock, class _Duration1, class _Duration2>
Marshall Clow5c459c92013-07-31 19:32:19 +00001545inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
Howard Hinnantc51e1022010-05-11 19:42:16 +00001546typename common_type<_Duration1, _Duration2>::type
1547operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs)
1548{
1549 return __lhs.time_since_epoch() - __rhs.time_since_epoch();
1550}
1551
1552//////////////////////////////////////////////////////////
1553/////////////////////// clocks ///////////////////////////
1554//////////////////////////////////////////////////////////
1555
Howard Hinnant8331b762013-03-06 23:30:19 +00001556class _LIBCPP_TYPE_VIS system_clock
Howard Hinnantc51e1022010-05-11 19:42:16 +00001557{
1558public:
1559 typedef microseconds duration;
1560 typedef duration::rep rep;
1561 typedef duration::period period;
1562 typedef chrono::time_point<system_clock> time_point;
Marshall Clow5c459c92013-07-31 19:32:19 +00001563 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001564
Howard Hinnantaa54ac42011-05-28 18:34:36 +00001565 static time_point now() _NOEXCEPT;
1566 static time_t to_time_t (const time_point& __t) _NOEXCEPT;
1567 static time_point from_time_t(time_t __t) _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001568};
1569
Jonathan Roelofscce96eb2014-09-02 21:14:38 +00001570#ifndef _LIBCPP_HAS_NO_MONOTONIC_CLOCK
Howard Hinnant8331b762013-03-06 23:30:19 +00001571class _LIBCPP_TYPE_VIS steady_clock
Howard Hinnantc51e1022010-05-11 19:42:16 +00001572{
1573public:
1574 typedef nanoseconds duration;
1575 typedef duration::rep rep;
1576 typedef duration::period period;
Howard Hinnantc8dbd222010-11-20 19:16:30 +00001577 typedef chrono::time_point<steady_clock, duration> time_point;
Marshall Clow5c459c92013-07-31 19:32:19 +00001578 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = true;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001579
Howard Hinnantaa54ac42011-05-28 18:34:36 +00001580 static time_point now() _NOEXCEPT;
Howard Hinnantc51e1022010-05-11 19:42:16 +00001581};
1582
Howard Hinnantc8dbd222010-11-20 19:16:30 +00001583typedef steady_clock high_resolution_clock;
Jonathan Roelofscce96eb2014-09-02 21:14:38 +00001584#else
1585typedef system_clock high_resolution_clock;
1586#endif
Howard Hinnantc51e1022010-05-11 19:42:16 +00001587
Marshall Clow26058352018-10-16 17:27:54 +00001588#if _LIBCPP_STD_VER > 17
Eric Fiselier049273c2018-12-21 03:54:57 +00001589// [time.clock.file], type file_clock
1590using file_clock = _VSTD_FS::_FilesystemClock;
1591
1592template<class _Duration>
1593using file_time = time_point<file_clock, _Duration>;
Marshall Clow26058352018-10-16 17:27:54 +00001594
1595struct _LIBCPP_TYPE_VIS last_spec { explicit last_spec() = default; };
1596
Marshall Clow26058352018-10-16 17:27:54 +00001597class _LIBCPP_TYPE_VIS day {
1598private:
1599 unsigned char __d;
1600public:
1601 day() = default;
1602 explicit inline constexpr day(unsigned __val) noexcept : __d(static_cast<unsigned char>(__val)) {}
1603 inline constexpr day& operator++() noexcept { ++__d; return *this; }
1604 inline constexpr day operator++(int) noexcept { day __tmp = *this; ++(*this); return __tmp; }
1605 inline constexpr day& operator--() noexcept { --__d; return *this; }
1606 inline constexpr day operator--(int) noexcept { day __tmp = *this; --(*this); return __tmp; }
1607 constexpr day& operator+=(const days& __dd) noexcept;
1608 constexpr day& operator-=(const days& __dd) noexcept;
1609 explicit inline constexpr operator unsigned() const noexcept { return __d; }
1610 inline constexpr bool ok() const noexcept { return __d >= 1 && __d <= 31; }
1611 };
1612
1613
1614inline constexpr
1615bool operator==(const day& __lhs, const day& __rhs) noexcept
1616{ return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); }
1617
1618inline constexpr
1619bool operator!=(const day& __lhs, const day& __rhs) noexcept
1620{ return !(__lhs == __rhs); }
1621
1622inline constexpr
1623bool operator< (const day& __lhs, const day& __rhs) noexcept
1624{ return static_cast<unsigned>(__lhs) < static_cast<unsigned>(__rhs); }
1625
1626inline constexpr
1627bool operator> (const day& __lhs, const day& __rhs) noexcept
1628{ return __rhs < __lhs; }
1629
1630inline constexpr
1631bool operator<=(const day& __lhs, const day& __rhs) noexcept
1632{ return !(__rhs < __lhs);}
1633
1634inline constexpr
1635bool operator>=(const day& __lhs, const day& __rhs) noexcept
1636{ return !(__lhs < __rhs); }
1637
1638inline constexpr
1639day operator+ (const day& __lhs, const days& __rhs) noexcept
1640{ return day(static_cast<unsigned>(__lhs) + __rhs.count()); }
1641
1642inline constexpr
1643day operator+ (const days& __lhs, const day& __rhs) noexcept
1644{ return __rhs + __lhs; }
1645
1646inline constexpr
1647day operator- (const day& __lhs, const days& __rhs) noexcept
1648{ return __lhs + -__rhs; }
1649
1650inline constexpr
1651days operator-(const day& __lhs, const day& __rhs) noexcept
1652{ return days(static_cast<int>(static_cast<unsigned>(__lhs)) -
1653 static_cast<int>(static_cast<unsigned>(__rhs))); }
1654
1655inline constexpr day& day::operator+=(const days& __dd) noexcept
1656{ *this = *this + __dd; return *this; }
1657
1658inline constexpr day& day::operator-=(const days& __dd) noexcept
1659{ *this = *this - __dd; return *this; }
1660
1661
1662class _LIBCPP_TYPE_VIS month {
1663private:
1664 unsigned char __m;
1665public:
1666 month() = default;
1667 explicit inline constexpr month(unsigned __val) noexcept : __m(static_cast<unsigned char>(__val)) {}
1668 inline constexpr month& operator++() noexcept { ++__m; return *this; }
1669 inline constexpr month operator++(int) noexcept { month __tmp = *this; ++(*this); return __tmp; }
1670 inline constexpr month& operator--() noexcept { --__m; return *this; }
1671 inline constexpr month operator--(int) noexcept { month __tmp = *this; --(*this); return __tmp; }
1672 constexpr month& operator+=(const months& __m1) noexcept;
1673 constexpr month& operator-=(const months& __m1) noexcept;
1674 explicit inline constexpr operator unsigned() const noexcept { return __m; }
1675 inline constexpr bool ok() const noexcept { return __m >= 1 && __m <= 12; }
1676};
1677
1678
1679inline constexpr
1680bool operator==(const month& __lhs, const month& __rhs) noexcept
1681{ return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); }
1682
1683inline constexpr
1684bool operator!=(const month& __lhs, const month& __rhs) noexcept
1685{ return !(__lhs == __rhs); }
1686
1687inline constexpr
1688bool operator< (const month& __lhs, const month& __rhs) noexcept
1689{ return static_cast<unsigned>(__lhs) < static_cast<unsigned>(__rhs); }
1690
1691inline constexpr
1692bool operator> (const month& __lhs, const month& __rhs) noexcept
1693{ return __rhs < __lhs; }
1694
1695inline constexpr
1696bool operator<=(const month& __lhs, const month& __rhs) noexcept
1697{ return !(__rhs < __lhs); }
1698
1699inline constexpr
1700bool operator>=(const month& __lhs, const month& __rhs) noexcept
1701{ return !(__lhs < __rhs); }
1702
1703inline constexpr
1704month operator+ (const month& __lhs, const months& __rhs) noexcept
1705{
1706 auto const __mu = static_cast<long long>(static_cast<unsigned>(__lhs)) + (__rhs.count() - 1);
1707 auto const __yr = (__mu >= 0 ? __mu : __mu - 11) / 12;
1708 return month{static_cast<unsigned>(__mu - __yr * 12 + 1)};
1709}
1710
1711inline constexpr
1712month operator+ (const months& __lhs, const month& __rhs) noexcept
1713{ return __rhs + __lhs; }
1714
1715inline constexpr
1716month operator- (const month& __lhs, const months& __rhs) noexcept
1717{ return __lhs + -__rhs; }
1718
1719inline constexpr
1720months operator-(const month& __lhs, const month& __rhs) noexcept
1721{
1722 auto const __dm = static_cast<unsigned>(__lhs) - static_cast<unsigned>(__rhs);
1723 return months(__dm <= 11 ? __dm : __dm + 12);
1724}
1725
1726inline constexpr month& month::operator+=(const months& __dm) noexcept
1727{ *this = *this + __dm; return *this; }
1728
1729inline constexpr month& month::operator-=(const months& __dm) noexcept
1730{ *this = *this - __dm; return *this; }
1731
1732
1733class _LIBCPP_TYPE_VIS year {
1734private:
1735 short __y;
1736public:
1737 year() = default;
1738 explicit inline constexpr year(int __val) noexcept : __y(static_cast<short>(__val)) {}
1739
1740 inline constexpr year& operator++() noexcept { ++__y; return *this; };
1741 inline constexpr year operator++(int) noexcept { year __tmp = *this; ++(*this); return __tmp; };
1742 inline constexpr year& operator--() noexcept { --__y; return *this; };
1743 inline constexpr year operator--(int) noexcept { year __tmp = *this; --(*this); return __tmp; };
1744 constexpr year& operator+=(const years& __dy) noexcept;
1745 constexpr year& operator-=(const years& __dy) noexcept;
1746 inline constexpr year operator+() const noexcept { return *this; }
1747 inline constexpr year operator-() const noexcept { return year{-__y}; };
1748
1749 inline constexpr bool is_leap() const noexcept { return __y % 4 == 0 && (__y % 100 != 0 || __y % 400 == 0); }
1750 explicit inline constexpr operator int() const noexcept { return __y; }
1751 constexpr bool ok() const noexcept;
1752 static inline constexpr year min() noexcept { return year{-32767}; }
1753 static inline constexpr year max() noexcept { return year{ 32767}; }
1754};
1755
1756
1757inline constexpr
1758bool operator==(const year& __lhs, const year& __rhs) noexcept
1759{ return static_cast<int>(__lhs) == static_cast<int>(__rhs); }
1760
1761inline constexpr
1762bool operator!=(const year& __lhs, const year& __rhs) noexcept
1763{ return !(__lhs == __rhs); }
1764
1765inline constexpr
1766bool operator< (const year& __lhs, const year& __rhs) noexcept
1767{ return static_cast<int>(__lhs) < static_cast<int>(__rhs); }
1768
1769inline constexpr
1770bool operator> (const year& __lhs, const year& __rhs) noexcept
1771{ return __rhs < __lhs; }
1772
1773inline constexpr
1774bool operator<=(const year& __lhs, const year& __rhs) noexcept
1775{ return !(__rhs < __lhs); }
1776
1777inline constexpr
1778bool operator>=(const year& __lhs, const year& __rhs) noexcept
1779{ return !(__lhs < __rhs); }
1780
1781inline constexpr
1782year operator+ (const year& __lhs, const years& __rhs) noexcept
1783{ return year(static_cast<int>(__lhs) + __rhs.count()); }
1784
1785inline constexpr
1786year operator+ (const years& __lhs, const year& __rhs) noexcept
1787{ return __rhs + __lhs; }
1788
1789inline constexpr
1790year operator- (const year& __lhs, const years& __rhs) noexcept
1791{ return __lhs + -__rhs; }
1792
1793inline constexpr
1794years operator-(const year& __lhs, const year& __rhs) noexcept
1795{ return years{static_cast<int>(__lhs) - static_cast<int>(__rhs)}; }
1796
1797
1798inline constexpr year& year::operator+=(const years& __dy) noexcept
1799{ *this = *this + __dy; return *this; }
1800
1801inline constexpr year& year::operator-=(const years& __dy) noexcept
1802{ *this = *this - __dy; return *this; }
1803
1804inline constexpr bool year::ok() const noexcept
1805{ return static_cast<int>(min()) <= __y && __y <= static_cast<int>(max()); }
1806
1807class _LIBCPP_TYPE_VIS weekday_indexed;
1808class _LIBCPP_TYPE_VIS weekday_last;
1809
1810class _LIBCPP_TYPE_VIS weekday {
1811private:
1812 unsigned char __wd;
1813public:
1814 weekday() = default;
1815 explicit inline constexpr weekday(unsigned __val) noexcept: __wd(static_cast<unsigned char>(__val)) {}
1816// inline constexpr weekday(const sys_days& dp) noexcept;
1817// explicit constexpr weekday(const local_days& dp) noexcept;
1818 inline constexpr weekday& operator++() noexcept { __wd = (__wd == 6 ? 0 : __wd + 1); return *this; }
1819 inline constexpr weekday operator++(int) noexcept { weekday __tmp = *this; ++(*this); return __tmp; }
1820 inline constexpr weekday& operator--() noexcept { __wd = (__wd == 0 ? 6 : __wd - 1); return *this; }
1821 inline constexpr weekday operator--(int) noexcept { weekday __tmp = *this; --(*this); return __tmp; }
1822 constexpr weekday& operator+=(const days& __dd) noexcept;
1823 constexpr weekday& operator-=(const days& __dd) noexcept;
1824 explicit inline constexpr operator unsigned() const noexcept { return __wd; }
1825 inline constexpr bool ok() const noexcept { return __wd <= 6; }
1826 constexpr weekday_indexed operator[](unsigned __index) const noexcept;
1827 constexpr weekday_last operator[](last_spec) const noexcept;
1828};
1829
1830inline constexpr
1831bool operator==(const weekday& __lhs, const weekday& __rhs) noexcept
1832{ return static_cast<unsigned>(__lhs) == static_cast<unsigned>(__rhs); }
1833
1834inline constexpr
1835bool operator!=(const weekday& __lhs, const weekday& __rhs) noexcept
1836{ return !(__lhs == __rhs); }
1837
1838inline constexpr
1839bool operator< (const weekday& __lhs, const weekday& __rhs) noexcept
1840{ return static_cast<unsigned>(__lhs) < static_cast<unsigned>(__rhs); }
1841
1842inline constexpr
1843bool operator> (const weekday& __lhs, const weekday& __rhs) noexcept
1844{ return __rhs < __lhs; }
1845
1846inline constexpr
1847bool operator<=(const weekday& __lhs, const weekday& __rhs) noexcept
1848{ return !(__rhs < __lhs);}
1849
1850inline constexpr
1851bool operator>=(const weekday& __lhs, const weekday& __rhs) noexcept
1852{ return !(__lhs < __rhs); }
1853
1854constexpr weekday operator+(const weekday& __lhs, const days& __rhs) noexcept
1855{
1856 auto const __mu = static_cast<long long>(static_cast<unsigned>(__lhs)) + __rhs.count();
1857 auto const __yr = (__mu >= 0 ? __mu : __mu - 6) / 7;
1858 return weekday{static_cast<unsigned>(__mu - __yr * 7)};
1859}
1860
1861constexpr weekday operator+(const days& __lhs, const weekday& __rhs) noexcept
1862{ return __rhs + __lhs; }
1863
1864constexpr weekday operator-(const weekday& __lhs, const days& __rhs) noexcept
1865{ return __lhs + -__rhs; }
1866
1867constexpr days operator-(const weekday& __lhs, const weekday& __rhs) noexcept
1868{
1869 const int __wdu = static_cast<unsigned>(__lhs) - static_cast<unsigned>(__rhs);
1870 const int __wk = (__wdu >= 0 ? __wdu : __wdu-6) / 7;
1871 return days{__wdu - __wk * 7};
1872}
1873
1874inline constexpr weekday& weekday::operator+=(const days& __dd) noexcept
1875{ *this = *this + __dd; return *this; }
1876
1877inline constexpr weekday& weekday::operator-=(const days& __dd) noexcept
1878{ *this = *this - __dd; return *this; }
1879
1880
1881class _LIBCPP_TYPE_VIS weekday_indexed {
1882private:
1883 _VSTD::chrono::weekday __wd;
1884 unsigned char __idx;
1885public:
1886 weekday_indexed() = default;
1887 inline constexpr weekday_indexed(const _VSTD::chrono::weekday& __wdval, unsigned __idxval) noexcept
1888 : __wd{__wdval}, __idx(__idxval) {}
1889 inline constexpr _VSTD::chrono::weekday weekday() const noexcept { return __wd; }
1890 inline constexpr unsigned index() const noexcept { return __idx; }
1891 inline constexpr bool ok() const noexcept { return __wd.ok() && __idx >= 1 && __idx <= 5; }
1892};
1893
1894inline constexpr
1895bool operator==(const weekday_indexed& __lhs, const weekday_indexed& __rhs) noexcept
1896{ return __lhs.weekday() == __rhs.weekday() && __lhs.index() == __rhs.index(); }
1897
1898inline constexpr
1899bool operator!=(const weekday_indexed& __lhs, const weekday_indexed& __rhs) noexcept
1900{ return !(__lhs == __rhs); }
1901
1902
1903class _LIBCPP_TYPE_VIS weekday_last {
1904private:
1905 _VSTD::chrono::weekday __wd;
1906public:
1907 explicit constexpr weekday_last(const _VSTD::chrono::weekday& __val) noexcept
1908 : __wd{__val} {}
1909 constexpr _VSTD::chrono::weekday weekday() const noexcept { return __wd; }
1910 constexpr bool ok() const noexcept { return __wd.ok(); }
1911};
1912
1913inline constexpr
1914bool operator==(const weekday_last& __lhs, const weekday_last& __rhs) noexcept
1915{ return __lhs.weekday() == __rhs.weekday(); }
1916
1917inline constexpr
1918bool operator!=(const weekday_last& __lhs, const weekday_last& __rhs) noexcept
1919{ return !(__lhs == __rhs); }
1920
1921inline constexpr
1922weekday_indexed weekday::operator[](unsigned __index) const noexcept { return weekday_indexed{*this, __index}; }
1923
1924inline constexpr
1925weekday_last weekday::operator[](last_spec) const noexcept { return weekday_last{*this}; }
1926
1927
1928inline constexpr last_spec last{};
1929inline constexpr weekday Sunday{0};
1930inline constexpr weekday Monday{1};
1931inline constexpr weekday Tuesday{2};
1932inline constexpr weekday Wednesday{3};
1933inline constexpr weekday Thursday{4};
1934inline constexpr weekday Friday{5};
1935inline constexpr weekday Saturday{6};
1936
1937inline constexpr month January{1};
1938inline constexpr month February{2};
1939inline constexpr month March{3};
1940inline constexpr month April{4};
1941inline constexpr month May{5};
1942inline constexpr month June{6};
1943inline constexpr month July{7};
1944inline constexpr month August{8};
1945inline constexpr month September{9};
1946inline constexpr month October{10};
1947inline constexpr month November{11};
1948inline constexpr month December{12};
1949
1950
1951class _LIBCPP_TYPE_VIS month_day {
1952private:
1953 chrono::month __m;
1954 chrono::day __d;
1955public:
1956 month_day() = default;
1957 constexpr month_day(const chrono::month& __mval, const chrono::day& __dval) noexcept
1958 : __m{__mval}, __d{__dval} {}
1959 inline constexpr chrono::month month() const noexcept { return __m; }
1960 inline constexpr chrono::day day() const noexcept { return __d; }
1961 constexpr bool ok() const noexcept;
1962};
1963
1964inline constexpr
1965bool month_day::ok() const noexcept
1966{
1967 if (!__m.ok()) return false;
1968 const unsigned __dval = static_cast<unsigned>(__d);
1969 if (__dval < 1 || __dval > 31) return false;
1970 if (__dval <= 29) return true;
1971// Now we've got either 30 or 31
1972 const unsigned __mval = static_cast<unsigned>(__m);
1973 if (__mval == 2) return false;
1974 if (__mval == 4 || __mval == 6 || __mval == 9 || __mval == 11)
1975 return __dval == 30;
1976 return true;
1977}
1978
1979inline constexpr
1980bool operator==(const month_day& __lhs, const month_day& __rhs) noexcept
1981{ return __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day(); }
1982
1983inline constexpr
1984bool operator!=(const month_day& __lhs, const month_day& __rhs) noexcept
1985{ return !(__lhs == __rhs); }
1986
1987inline constexpr
1988month_day operator/(const month& __lhs, const day& __rhs) noexcept
1989{ return month_day{__lhs, __rhs}; }
1990
1991constexpr
1992month_day operator/(const day& __lhs, const month& __rhs) noexcept
1993{ return __rhs / __lhs; }
1994
1995inline constexpr
1996month_day operator/(const month& __lhs, int __rhs) noexcept
1997{ return __lhs / day(__rhs); }
1998
1999constexpr
2000month_day operator/(int __lhs, const day& __rhs) noexcept
2001{ return month(__lhs) / __rhs; }
2002
2003constexpr
2004month_day operator/(const day& __lhs, int __rhs) noexcept
2005{ return month(__rhs) / __lhs; }
2006
2007
2008inline constexpr
2009bool operator< (const month_day& __lhs, const month_day& __rhs) noexcept
2010{ return __lhs.month() != __rhs.month() ? __lhs.month() < __rhs.month() : __lhs.day() < __rhs.day(); }
2011
2012inline constexpr
2013bool operator> (const month_day& __lhs, const month_day& __rhs) noexcept
2014{ return __rhs < __lhs; }
2015
2016inline constexpr
2017bool operator<=(const month_day& __lhs, const month_day& __rhs) noexcept
2018{ return !(__rhs < __lhs);}
2019
2020inline constexpr
2021bool operator>=(const month_day& __lhs, const month_day& __rhs) noexcept
2022{ return !(__lhs < __rhs); }
2023
2024
2025
2026class _LIBCPP_TYPE_VIS month_day_last {
2027private:
2028 chrono::month __m;
2029public:
2030 explicit constexpr month_day_last(const chrono::month& __val) noexcept
2031 : __m{__val} {}
2032 inline constexpr chrono::month month() const noexcept { return __m; }
2033 inline constexpr bool ok() const noexcept { return __m.ok(); }
2034};
2035
2036inline constexpr
2037bool operator==(const month_day_last& __lhs, const month_day_last& __rhs) noexcept
2038{ return __lhs.month() == __rhs.month(); }
2039
2040inline constexpr
2041bool operator!=(const month_day_last& __lhs, const month_day_last& __rhs) noexcept
2042{ return !(__lhs == __rhs); }
2043
2044inline constexpr
2045bool operator< (const month_day_last& __lhs, const month_day_last& __rhs) noexcept
2046{ return __lhs.month() < __rhs.month(); }
2047
2048inline constexpr
2049bool operator> (const month_day_last& __lhs, const month_day_last& __rhs) noexcept
2050{ return __rhs < __lhs; }
2051
2052inline constexpr
2053bool operator<=(const month_day_last& __lhs, const month_day_last& __rhs) noexcept
2054{ return !(__rhs < __lhs);}
2055
2056inline constexpr
2057bool operator>=(const month_day_last& __lhs, const month_day_last& __rhs) noexcept
2058{ return !(__lhs < __rhs); }
2059
2060inline constexpr
2061month_day_last operator/(const month& __lhs, last_spec) noexcept
2062{ return month_day_last{__lhs}; }
2063
2064inline constexpr
2065month_day_last operator/(last_spec, const month& __rhs) noexcept
2066{ return month_day_last{__rhs}; }
2067
2068inline constexpr
2069month_day_last operator/(int __lhs, last_spec) noexcept
2070{ return month_day_last{month(__lhs)}; }
2071
2072inline constexpr
2073month_day_last operator/(last_spec, int __rhs) noexcept
2074{ return month_day_last{month(__rhs)}; }
2075
2076
2077class _LIBCPP_TYPE_VIS month_weekday {
2078private:
2079 chrono::month __m;
2080 chrono::weekday_indexed __wdi;
2081public:
2082 month_weekday() = default;
2083 constexpr month_weekday(const chrono::month& __mval, const chrono::weekday_indexed& __wdival) noexcept
2084 : __m{__mval}, __wdi{__wdival} {}
2085 inline constexpr chrono::month month() const noexcept { return __m; }
2086 inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi; }
2087 inline constexpr bool ok() const noexcept { return __m.ok() && __wdi.ok(); }
2088};
2089
2090inline constexpr
2091bool operator==(const month_weekday& __lhs, const month_weekday& __rhs) noexcept
2092{ return __lhs.month() == __rhs.month() && __lhs.weekday_indexed() == __rhs.weekday_indexed(); }
2093
2094inline constexpr
2095bool operator!=(const month_weekday& __lhs, const month_weekday& __rhs) noexcept
2096{ return !(__lhs == __rhs); }
2097
2098inline constexpr
2099month_weekday operator/(const month& __lhs, const weekday_indexed& __rhs) noexcept
2100{ return month_weekday{__lhs, __rhs}; }
2101
2102inline constexpr
2103month_weekday operator/(int __lhs, const weekday_indexed& __rhs) noexcept
2104{ return month_weekday{month(__lhs), __rhs}; }
2105
2106inline constexpr
2107month_weekday operator/(const weekday_indexed& __lhs, const month& __rhs) noexcept
2108{ return month_weekday{__rhs, __lhs}; }
2109
2110inline constexpr
2111month_weekday operator/(const weekday_indexed& __lhs, int __rhs) noexcept
2112{ return month_weekday{month(__rhs), __lhs}; }
2113
2114
2115class _LIBCPP_TYPE_VIS month_weekday_last {
2116 chrono::month __m;
2117 chrono::weekday_last __wdl;
2118 public:
2119 constexpr month_weekday_last(const chrono::month& __mval, const chrono::weekday_last& __wdlval) noexcept
2120 : __m{__mval}, __wdl{__wdlval} {}
2121 inline constexpr chrono::month month() const noexcept { return __m; }
2122 inline constexpr chrono::weekday_last weekday_last() const noexcept { return __wdl; }
2123 inline constexpr bool ok() const noexcept { return __m.ok() && __wdl.ok(); }
2124};
2125
2126inline constexpr
2127bool operator==(const month_weekday_last& __lhs, const month_weekday_last& __rhs) noexcept
2128{ return __lhs.month() == __rhs.month() && __lhs.weekday_last() == __rhs.weekday_last(); }
2129
2130inline constexpr
2131bool operator!=(const month_weekday_last& __lhs, const month_weekday_last& __rhs) noexcept
2132{ return !(__lhs == __rhs); }
2133
2134
2135inline constexpr
2136month_weekday_last operator/(const month& __lhs, const weekday_last& __rhs) noexcept
2137{ return month_weekday_last{__lhs, __rhs}; }
2138
2139inline constexpr
2140month_weekday_last operator/(int __lhs, const weekday_last& __rhs) noexcept
2141{ return month_weekday_last{month(__lhs), __rhs}; }
2142
2143inline constexpr
2144month_weekday_last operator/(const weekday_last& __lhs, const month& __rhs) noexcept
2145{ return month_weekday_last{__rhs, __lhs}; }
2146
2147inline constexpr
2148month_weekday_last operator/(const weekday_last& __lhs, int __rhs) noexcept
2149{ return month_weekday_last{month(__rhs), __lhs}; }
2150
2151
2152class _LIBCPP_TYPE_VIS year_month {
2153 chrono::year __y;
2154 chrono::month __m;
2155public:
2156 year_month() = default;
2157 constexpr year_month(const chrono::year& __yval, const chrono::month& __mval) noexcept
2158 : __y{__yval}, __m{__mval} {}
2159 inline constexpr chrono::year year() const noexcept { return __y; }
2160 inline constexpr chrono::month month() const noexcept { return __m; }
2161 inline constexpr year_month& operator+=(const months& __dm) noexcept { this->__m += __dm; return *this; }
2162 inline constexpr year_month& operator-=(const months& __dm) noexcept { this->__m -= __dm; return *this; }
2163 inline constexpr year_month& operator+=(const years& __dy) noexcept { this->__y += __dy; return *this; }
2164 inline constexpr year_month& operator-=(const years& __dy) noexcept { this->__y -= __dy; return *this; }
2165 inline constexpr bool ok() const noexcept { return __y.ok() && __m.ok(); }
2166};
2167
2168inline constexpr
2169year_month operator/(const year& __y, const month& __m) noexcept { return year_month{__y, __m}; }
2170
2171inline constexpr
2172year_month operator/(const year& __y, int __m) noexcept { return year_month{__y, month(__m)}; }
2173
2174inline constexpr
2175bool operator==(const year_month& __lhs, const year_month& __rhs) noexcept
2176{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month(); }
2177
2178inline constexpr
2179bool operator!=(const year_month& __lhs, const year_month& __rhs) noexcept
2180{ return !(__lhs == __rhs); }
2181
2182inline constexpr
2183bool operator< (const year_month& __lhs, const year_month& __rhs) noexcept
2184{ return __lhs.year() != __rhs.year() ? __lhs.year() < __rhs.year() : __lhs.month() < __rhs.month(); }
2185
2186inline constexpr
2187bool operator> (const year_month& __lhs, const year_month& __rhs) noexcept
2188{ return __rhs < __lhs; }
2189
2190inline constexpr
2191bool operator<=(const year_month& __lhs, const year_month& __rhs) noexcept
2192{ return !(__rhs < __lhs);}
2193
2194inline constexpr
2195bool operator>=(const year_month& __lhs, const year_month& __rhs) noexcept
2196{ return !(__lhs < __rhs); }
2197
2198constexpr year_month operator+(const year_month& __lhs, const months& __rhs) noexcept
2199{
2200 int __dmi = static_cast<int>(static_cast<unsigned>(__lhs.month())) - 1 + __rhs.count();
2201 const int __dy = (__dmi >= 0 ? __dmi : __dmi-11) / 12;
2202 __dmi = __dmi - __dy * 12 + 1;
2203 return (__lhs.year() + years(__dy)) / month(static_cast<unsigned>(__dmi));
2204}
2205
2206constexpr year_month operator+(const months& __lhs, const year_month& __rhs) noexcept
2207{ return __rhs + __lhs; }
2208
2209constexpr year_month operator+(const year_month& __lhs, const years& __rhs) noexcept
2210{ return (__lhs.year() + __rhs) / __lhs.month(); }
2211
2212constexpr year_month operator+(const years& __lhs, const year_month& __rhs) noexcept
2213{ return __rhs + __lhs; }
2214
2215constexpr months operator-(const year_month& __lhs, const year_month& __rhs) noexcept
2216{ return (__lhs.year() - __rhs.year()) + months(static_cast<unsigned>(__lhs.month()) - static_cast<unsigned>(__rhs.month())); }
2217
2218constexpr year_month operator-(const year_month& __lhs, const months& __rhs) noexcept
2219{ return __lhs + -__rhs; }
2220
2221constexpr year_month operator-(const year_month& __lhs, const years& __rhs) noexcept
2222{ return __lhs + -__rhs; }
2223
2224
2225class _LIBCPP_TYPE_VIS year_month_day {
2226private:
2227 chrono::year __y;
2228 chrono::month __m;
2229 chrono::day __d;
2230public:
2231 year_month_day() = default;
2232 inline constexpr year_month_day(
2233 const chrono::year& __yval, const chrono::month& __mval, const chrono::day& __dval) noexcept
2234 : __y{__yval}, __m{__mval}, __d{__dval} {}
2235// inline constexpr year_month_day(const year_month_day_last& __ymdl) noexcept;
2236// inline constexpr year_month_day(const sys_days& dp) noexcept;
2237// inline explicit constexpr year_month_day(const local_days& dp) noexcept;
2238 constexpr year_month_day& operator+=(const months& __dm) noexcept;
2239 constexpr year_month_day& operator-=(const months& __dm) noexcept;
2240 constexpr year_month_day& operator+=(const years& __dy) noexcept;
2241 constexpr year_month_day& operator-=(const years& __dy) noexcept;
2242 inline constexpr chrono::year year() const noexcept { return __y; }
2243 inline constexpr chrono::month month() const noexcept { return __m; }
2244 inline constexpr chrono::day day() const noexcept { return __d; }
2245// inline constexpr operator sys_days() const noexcept;
2246// inline explicit constexpr operator local_days() const noexcept;
2247
2248// TODO: This is not quite correct; requires the calendar bits to do right
2249// d_ is in the range [1d, (y_/m_/last).day()],
2250 inline constexpr bool ok() const noexcept { return __y.ok() && __m.ok() && __d.ok(); }
2251};
2252
2253inline constexpr
2254bool operator==(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
2255{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.day() == __rhs.day(); }
2256
2257inline constexpr
2258bool operator!=(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
2259{ return !(__lhs == __rhs); }
2260
2261inline constexpr
2262bool operator< (const year_month_day& __lhs, const year_month_day& __rhs) noexcept
2263{
2264 if (__lhs.year() < __rhs.year()) return true;
2265 if (__lhs.year() > __rhs.year()) return false;
2266 if (__lhs.month() < __rhs.month()) return true;
2267 if (__lhs.month() > __rhs.month()) return false;
2268 return __lhs.day() < __rhs.day();
2269}
2270
2271inline constexpr
2272bool operator> (const year_month_day& __lhs, const year_month_day& __rhs) noexcept
2273{ return __rhs < __lhs; }
2274
2275inline constexpr
2276bool operator<=(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
2277{ return !(__rhs < __lhs);}
2278
2279inline constexpr
2280bool operator>=(const year_month_day& __lhs, const year_month_day& __rhs) noexcept
2281{ return !(__lhs < __rhs); }
2282
2283inline constexpr
2284year_month_day operator/(const year_month& __lhs, const day& __rhs) noexcept
2285{ return year_month_day{__lhs.year(), __lhs.month(), __rhs}; }
2286
2287inline constexpr
2288year_month_day operator/(const year_month& __lhs, int __rhs) noexcept
2289{ return __lhs / day(__rhs); }
2290
2291inline constexpr
2292year_month_day operator/(const year& __lhs, const month_day& __rhs) noexcept
2293{ return __lhs / __rhs.month() / __rhs.day(); }
2294
2295inline constexpr
2296year_month_day operator/(int __lhs, const month_day& __rhs) noexcept
2297{ return year(__lhs) / __rhs; }
2298
2299inline constexpr
2300year_month_day operator/(const month_day& __lhs, const year& __rhs) noexcept
2301{ return __rhs / __lhs; }
2302
2303inline constexpr
2304year_month_day operator/(const month_day& __lhs, int __rhs) noexcept
2305{ return year(__rhs) / __lhs; }
2306
2307
2308inline constexpr
2309year_month_day operator+(const year_month_day& __lhs, const months& __rhs) noexcept
2310{ return (__lhs.year()/__lhs.month() + __rhs)/__lhs.day(); }
2311
2312inline constexpr
2313year_month_day operator+(const months& __lhs, const year_month_day& __rhs) noexcept
2314{ return __rhs + __lhs; }
2315
2316inline constexpr
2317year_month_day operator-(const year_month_day& __lhs, const months& __rhs) noexcept
2318{ return __lhs + -__rhs; }
2319
2320inline constexpr
2321year_month_day operator+(const year_month_day& __lhs, const years& __rhs) noexcept
2322{ return (__lhs.year() + __rhs) / __lhs.month() / __lhs.day(); }
2323
2324inline constexpr
2325year_month_day operator+(const years& __lhs, const year_month_day& __rhs) noexcept
2326{ return __rhs + __lhs; }
2327
2328inline constexpr
2329year_month_day operator-(const year_month_day& __lhs, const years& __rhs) noexcept
2330{ return __lhs + -__rhs; }
2331
2332inline constexpr year_month_day& year_month_day::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; }
2333inline constexpr year_month_day& year_month_day::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; }
2334inline constexpr year_month_day& year_month_day::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; }
2335inline constexpr year_month_day& year_month_day::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; }
2336
2337class _LIBCPP_TYPE_VIS year_month_day_last {
2338private:
2339 chrono::year __y;
2340 chrono::month_day_last __mdl;
2341public:
2342 constexpr year_month_day_last(const year& __yval, const month_day_last& __mdlval) noexcept
2343 : __y{__yval}, __mdl{__mdlval} {}
2344
2345 constexpr year_month_day_last& operator+=(const months& __m) noexcept;
2346 constexpr year_month_day_last& operator-=(const months& __m) noexcept;
2347 constexpr year_month_day_last& operator+=(const years& __y) noexcept;
2348 constexpr year_month_day_last& operator-=(const years& __y) noexcept;
2349
2350 constexpr chrono::year year() const noexcept { return __y; }
2351 constexpr chrono::month month() const noexcept { return __mdl.month(); }
2352 constexpr chrono::month_day_last month_day_last() const noexcept { return __mdl; }
2353// constexpr chrono::day day() const noexcept;
2354// constexpr operator sys_days() const noexcept;
2355// explicit constexpr operator local_days() const noexcept;
2356 constexpr bool ok() const noexcept { return __y.ok() && __mdl.ok(); }
2357};
2358
2359inline constexpr
2360bool operator==(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
2361{ return __lhs.year() == __rhs.year() && __lhs.month_day_last() == __rhs.month_day_last(); }
2362
2363inline constexpr
2364bool operator!=(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
2365{ return !(__lhs == __rhs); }
2366
2367inline constexpr
2368bool operator< (const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
2369{
2370 if (__lhs.year() < __rhs.year()) return true;
2371 if (__lhs.year() > __rhs.year()) return false;
2372 return __lhs.month_day_last() < __rhs.month_day_last();
2373}
2374
2375inline constexpr
2376bool operator> (const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
2377{ return __rhs < __lhs; }
2378
2379inline constexpr
2380bool operator<=(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
2381{ return !(__rhs < __lhs);}
2382
2383inline constexpr
2384bool operator>=(const year_month_day_last& __lhs, const year_month_day_last& __rhs) noexcept
2385{ return !(__lhs < __rhs); }
2386
2387inline constexpr year_month_day_last operator/(const year_month& __lhs, last_spec) noexcept
2388{ return year_month_day_last{__lhs.year(), month_day_last{__lhs.month()}}; }
2389
2390inline constexpr year_month_day_last operator/(const year& __lhs, const month_day_last& __rhs) noexcept
2391{ return year_month_day_last{__lhs, __rhs}; }
2392
2393inline constexpr year_month_day_last operator/(int __lhs, const month_day_last& __rhs) noexcept
2394{ return year_month_day_last{year{__lhs}, __rhs}; }
2395
2396inline constexpr year_month_day_last operator/(const month_day_last& __lhs, const year& __rhs) noexcept
2397{ return __rhs / __lhs; }
2398
2399inline constexpr year_month_day_last operator/(const month_day_last& __lhs, int __rhs) noexcept
2400{ return year{__rhs} / __lhs; }
2401
2402
2403inline constexpr
2404year_month_day_last operator+(const year_month_day_last& __lhs, const months& __rhs) noexcept
2405{ return (__lhs.year() / __lhs.month() + __rhs) / last; }
2406
2407inline constexpr
2408year_month_day_last operator+(const months& __lhs, const year_month_day_last& __rhs) noexcept
2409{ return __rhs + __lhs; }
2410
2411inline constexpr
2412year_month_day_last operator-(const year_month_day_last& __lhs, const months& __rhs) noexcept
2413{ return __lhs + (-__rhs); }
2414
2415inline constexpr
2416year_month_day_last operator+(const year_month_day_last& __lhs, const years& __rhs) noexcept
2417{ return year_month_day_last{__lhs.year() + __rhs, __lhs.month_day_last()}; }
2418
2419inline constexpr
2420year_month_day_last operator+(const years& __lhs, const year_month_day_last& __rhs) noexcept
2421{ return __rhs + __lhs; }
2422
2423inline constexpr
2424year_month_day_last operator-(const year_month_day_last& __lhs, const years& __rhs) noexcept
2425{ return __lhs + (-__rhs); }
2426
2427inline constexpr year_month_day_last& year_month_day_last::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; }
2428inline constexpr year_month_day_last& year_month_day_last::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; }
2429inline constexpr year_month_day_last& year_month_day_last::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; }
2430inline constexpr year_month_day_last& year_month_day_last::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; }
2431
2432class _LIBCPP_TYPE_VIS year_month_weekday {
2433 chrono::year __y;
2434 chrono::month __m;
2435 chrono::weekday_indexed __wdi;
2436public:
2437 year_month_weekday() = default;
2438 constexpr year_month_weekday(const chrono::year& __yval, const chrono::month& __mval,
2439 const chrono::weekday_indexed& __wdival) noexcept
2440 : __y{__yval}, __m{__mval}, __wdi{__wdival} {}
2441// constexpr year_month_weekday(const sys_days& dp) noexcept;
2442// explicit constexpr year_month_weekday(const local_days& dp) noexcept;
2443 constexpr year_month_weekday& operator+=(const months& m) noexcept;
2444 constexpr year_month_weekday& operator-=(const months& m) noexcept;
2445 constexpr year_month_weekday& operator+=(const years& y) noexcept;
2446 constexpr year_month_weekday& operator-=(const years& y) noexcept;
2447
2448 inline constexpr chrono::year year() const noexcept { return __y; }
2449 inline constexpr chrono::month month() const noexcept { return __m; }
2450 inline constexpr chrono::weekday weekday() const noexcept { return __wdi.weekday(); }
2451 inline constexpr unsigned index() const noexcept { return __wdi.index(); }
2452 inline constexpr chrono::weekday_indexed weekday_indexed() const noexcept { return __wdi; }
2453
2454// constexpr operator sys_days() const noexcept;
2455// explicit constexpr operator local_days() const noexcept;
2456 inline constexpr bool ok() const noexcept
2457 {
2458 if (!__y.ok() || !__m.ok() || !__wdi.ok()) return false;
2459 // TODO: make sure it's a valid date
2460 return true;
2461 }
2462};
2463
2464inline constexpr
2465bool operator==(const year_month_weekday& __lhs, const year_month_weekday& __rhs) noexcept
2466{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.weekday_indexed() == __rhs.weekday_indexed(); }
2467
2468inline constexpr
2469bool operator!=(const year_month_weekday& __lhs, const year_month_weekday& __rhs) noexcept
2470{ return !(__lhs == __rhs); }
2471
2472inline constexpr
2473year_month_weekday operator/(const year_month& __lhs, const weekday_indexed& __rhs) noexcept
2474{ return year_month_weekday{__lhs.year(), __lhs.month(), __rhs}; }
2475
2476inline constexpr
2477year_month_weekday operator/(const year& __lhs, const month_weekday& __rhs) noexcept
2478{ return year_month_weekday{__lhs, __rhs.month(), __rhs.weekday_indexed()}; }
2479
2480inline constexpr
2481year_month_weekday operator/(int __lhs, const month_weekday& __rhs) noexcept
2482{ return year(__lhs) / __rhs; }
2483
2484inline constexpr
2485year_month_weekday operator/(const month_weekday& __lhs, const year& __rhs) noexcept
2486{ return __rhs / __lhs; }
2487
2488inline constexpr
2489year_month_weekday operator/(const month_weekday& __lhs, int __rhs) noexcept
2490{ return year(__rhs) / __lhs; }
2491
2492
2493inline constexpr
2494year_month_weekday operator+(const year_month_weekday& __lhs, const months& __rhs) noexcept
2495{ return (__lhs.year() / __lhs.month() + __rhs) / __lhs.weekday_indexed(); }
2496
2497inline constexpr
2498year_month_weekday operator+(const months& __lhs, const year_month_weekday& __rhs) noexcept
2499{ return __rhs + __lhs; }
2500
2501inline constexpr
2502year_month_weekday operator-(const year_month_weekday& __lhs, const months& __rhs) noexcept
2503{ return __lhs + (-__rhs); }
2504
2505inline constexpr
2506year_month_weekday operator+(const year_month_weekday& __lhs, const years& __rhs) noexcept
2507{ return year_month_weekday{__lhs.year() + __rhs, __lhs.month(), __lhs.weekday_indexed()}; }
2508
2509inline constexpr
2510year_month_weekday operator+(const years& __lhs, const year_month_weekday& __rhs) noexcept
2511{ return __rhs + __lhs; }
2512
2513inline constexpr
2514year_month_weekday operator-(const year_month_weekday& __lhs, const years& __rhs) noexcept
2515{ return __lhs + (-__rhs); }
2516
2517
2518inline constexpr year_month_weekday& year_month_weekday::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; }
2519inline constexpr year_month_weekday& year_month_weekday::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; }
2520inline constexpr year_month_weekday& year_month_weekday::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; }
2521inline constexpr year_month_weekday& year_month_weekday::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; }
2522
2523class _LIBCPP_TYPE_VIS year_month_weekday_last {
2524private:
2525 chrono::year __y;
2526 chrono::month __m;
2527 chrono::weekday_last __wdl;
2528public:
2529 constexpr year_month_weekday_last(const chrono::year& __yval, const chrono::month& __mval,
2530 const chrono::weekday_last& __wdlval) noexcept
2531 : __y{__yval}, __m{__mval}, __wdl{__wdlval} {}
2532 constexpr year_month_weekday_last& operator+=(const months& __dm) noexcept;
2533 constexpr year_month_weekday_last& operator-=(const months& __dm) noexcept;
2534 constexpr year_month_weekday_last& operator+=(const years& __dy) noexcept;
2535 constexpr year_month_weekday_last& operator-=(const years& __dy) noexcept;
2536
2537 inline constexpr chrono::year year() const noexcept { return __y; }
2538 inline constexpr chrono::month month() const noexcept { return __m; }
2539 inline constexpr chrono::weekday weekday() const noexcept { return __wdl.weekday(); }
2540 inline constexpr chrono::weekday_last weekday_last() const noexcept { return __wdl; }
2541// constexpr operator sys_days() const noexcept;
2542// explicit constexpr operator local_days() const noexcept;
2543 inline constexpr bool ok() const noexcept { return __y.ok() && __m.ok() && __wdl.ok(); }
2544};
2545
2546inline constexpr
2547bool operator==(const year_month_weekday_last& __lhs, const year_month_weekday_last& __rhs) noexcept
2548{ return __lhs.year() == __rhs.year() && __lhs.month() == __rhs.month() && __lhs.weekday_last() == __rhs.weekday_last(); }
2549
2550inline constexpr
2551bool operator!=(const year_month_weekday_last& __lhs, const year_month_weekday_last& __rhs) noexcept
2552{ return !(__lhs == __rhs); }
2553
2554
2555inline constexpr
2556year_month_weekday_last operator/(const year_month& __lhs, const weekday_last& __rhs) noexcept
2557{ return year_month_weekday_last{__lhs.year(), __lhs.month(), __rhs}; }
2558
2559inline constexpr
2560year_month_weekday_last operator/(const year& __lhs, const month_weekday_last& __rhs) noexcept
2561{ return year_month_weekday_last{__lhs, __rhs.month(), __rhs.weekday_last()}; }
2562
2563inline constexpr
2564year_month_weekday_last operator/(int __lhs, const month_weekday_last& __rhs) noexcept
2565{ return year(__lhs) / __rhs; }
2566
2567inline constexpr
2568year_month_weekday_last operator/(const month_weekday_last& __lhs, const year& __rhs) noexcept
2569{ return __rhs / __lhs; }
2570
2571inline constexpr
2572year_month_weekday_last operator/(const month_weekday_last& __lhs, int __rhs) noexcept
2573{ return year(__rhs) / __lhs; }
2574
2575
2576inline constexpr
2577year_month_weekday_last operator+(const year_month_weekday_last& __lhs, const months& __rhs) noexcept
2578{ return (__lhs.year() / __lhs.month() + __rhs) / __lhs.weekday_last(); }
2579
2580inline constexpr
2581year_month_weekday_last operator+(const months& __lhs, const year_month_weekday_last& __rhs) noexcept
2582{ return __rhs + __lhs; }
2583
2584inline constexpr
2585year_month_weekday_last operator-(const year_month_weekday_last& __lhs, const months& __rhs) noexcept
2586{ return __lhs + (-__rhs); }
2587
2588inline constexpr
2589year_month_weekday_last operator+(const year_month_weekday_last& __lhs, const years& __rhs) noexcept
2590{ return year_month_weekday_last{__lhs.year() + __rhs, __lhs.month(), __lhs.weekday_last()}; }
2591
2592inline constexpr
2593year_month_weekday_last operator+(const years& __lhs, const year_month_weekday_last& __rhs) noexcept
2594{ return __rhs + __lhs; }
2595
2596inline constexpr
2597year_month_weekday_last operator-(const year_month_weekday_last& __lhs, const years& __rhs) noexcept
2598{ return __lhs + (-__rhs); }
2599
2600inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const months& __dm) noexcept { *this = *this + __dm; return *this; }
2601inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const months& __dm) noexcept { *this = *this - __dm; return *this; }
2602inline constexpr year_month_weekday_last& year_month_weekday_last::operator+=(const years& __dy) noexcept { *this = *this + __dy; return *this; }
2603inline constexpr year_month_weekday_last& year_month_weekday_last::operator-=(const years& __dy) noexcept { *this = *this - __dy; return *this; }
2604
2605#endif // _LIBCPP_STD_VER > 17
Howard Hinnantc51e1022010-05-11 19:42:16 +00002606} // chrono
2607
Marshall Clowac868372013-10-05 21:18:32 +00002608#if _LIBCPP_STD_VER > 11
2609// Suffixes for duration literals [time.duration.literals]
2610inline namespace literals
Louis Dionne44bcff92018-08-03 22:36:53 +00002611{
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002612 inline namespace chrono_literals
2613 {
2614
Marshall Clow2ac805a2017-08-09 15:42:50 +00002615 constexpr chrono::hours operator""h(unsigned long long __h)
Howard Hinnant5c167562013-08-07 19:39:48 +00002616 {
2617 return chrono::hours(static_cast<chrono::hours::rep>(__h));
2618 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002619
Marshall Clow2ac805a2017-08-09 15:42:50 +00002620 constexpr chrono::duration<long double, ratio<3600,1>> operator""h(long double __h)
Howard Hinnant5c167562013-08-07 19:39:48 +00002621 {
2622 return chrono::duration<long double, ratio<3600,1>>(__h);
2623 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002624
2625
Marshall Clow2ac805a2017-08-09 15:42:50 +00002626 constexpr chrono::minutes operator""min(unsigned long long __m)
Howard Hinnant5c167562013-08-07 19:39:48 +00002627 {
2628 return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
2629 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002630
Marshall Clow2ac805a2017-08-09 15:42:50 +00002631 constexpr chrono::duration<long double, ratio<60,1>> operator""min(long double __m)
Howard Hinnant5c167562013-08-07 19:39:48 +00002632 {
2633 return chrono::duration<long double, ratio<60,1>> (__m);
2634 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002635
2636
Marshall Clow2ac805a2017-08-09 15:42:50 +00002637 constexpr chrono::seconds operator""s(unsigned long long __s)
Howard Hinnant5c167562013-08-07 19:39:48 +00002638 {
2639 return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
2640 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002641
Marshall Clow2ac805a2017-08-09 15:42:50 +00002642 constexpr chrono::duration<long double> operator""s(long double __s)
Howard Hinnant5c167562013-08-07 19:39:48 +00002643 {
2644 return chrono::duration<long double> (__s);
2645 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002646
2647
Marshall Clow2ac805a2017-08-09 15:42:50 +00002648 constexpr chrono::milliseconds operator""ms(unsigned long long __ms)
Howard Hinnant5c167562013-08-07 19:39:48 +00002649 {
2650 return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
2651 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002652
Marshall Clow2ac805a2017-08-09 15:42:50 +00002653 constexpr chrono::duration<long double, milli> operator""ms(long double __ms)
Howard Hinnant5c167562013-08-07 19:39:48 +00002654 {
2655 return chrono::duration<long double, milli>(__ms);
2656 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002657
2658
Marshall Clow2ac805a2017-08-09 15:42:50 +00002659 constexpr chrono::microseconds operator""us(unsigned long long __us)
Howard Hinnant5c167562013-08-07 19:39:48 +00002660 {
2661 return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
2662 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002663
Marshall Clow2ac805a2017-08-09 15:42:50 +00002664 constexpr chrono::duration<long double, micro> operator""us(long double __us)
Howard Hinnant5c167562013-08-07 19:39:48 +00002665 {
2666 return chrono::duration<long double, micro> (__us);
2667 }
Louis Dionne44bcff92018-08-03 22:36:53 +00002668
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002669
Marshall Clow2ac805a2017-08-09 15:42:50 +00002670 constexpr chrono::nanoseconds operator""ns(unsigned long long __ns)
Howard Hinnant5c167562013-08-07 19:39:48 +00002671 {
2672 return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
2673 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002674
Marshall Clow2ac805a2017-08-09 15:42:50 +00002675 constexpr chrono::duration<long double, nano> operator""ns(long double __ns)
Howard Hinnant5c167562013-08-07 19:39:48 +00002676 {
2677 return chrono::duration<long double, nano> (__ns);
2678 }
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002679
Marshall Clow26058352018-10-16 17:27:54 +00002680#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CXX20_CHRONO_LITERALS)
2681 constexpr chrono::day operator ""d(unsigned long long __d) noexcept
2682 {
2683 return chrono::day(static_cast<unsigned>(__d));
2684 }
2685
2686 constexpr chrono::year operator ""y(unsigned long long __y) noexcept
2687 {
2688 return chrono::year(static_cast<int>(__y));
2689 }
2690#endif
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002691}}
Marshall Clowac868372013-10-05 21:18:32 +00002692
2693namespace chrono { // hoist the literals into namespace std::chrono
2694 using namespace literals::chrono_literals;
2695}
2696
Marshall Cloweb41e5c2013-07-24 21:18:14 +00002697#endif
2698
Howard Hinnantc51e1022010-05-11 19:42:16 +00002699_LIBCPP_END_NAMESPACE_STD
2700
Eric Fiselier049273c2018-12-21 03:54:57 +00002701#ifndef _LIBCPP_CXX03_LANG
2702_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
2703struct _FilesystemClock {
2704#if !defined(_LIBCPP_HAS_NO_INT128)
2705 typedef __int128_t rep;
2706 typedef nano period;
2707#else
2708 typedef long long rep;
2709 typedef nano period;
2710#endif
2711
2712 typedef chrono::duration<rep, period> duration;
2713 typedef chrono::time_point<_FilesystemClock> time_point;
2714
2715 static _LIBCPP_CONSTEXPR_AFTER_CXX11 const bool is_steady = false;
2716
2717 _LIBCPP_FUNC_VIS static time_point now() noexcept;
2718
2719 _LIBCPP_INLINE_VISIBILITY
2720 static time_t to_time_t(const time_point& __t) noexcept {
2721 typedef chrono::duration<rep> __secs;
2722 return time_t(
2723 chrono::duration_cast<__secs>(__t.time_since_epoch()).count());
2724 }
2725
2726 _LIBCPP_INLINE_VISIBILITY
2727 static time_point from_time_t(time_t __t) noexcept {
2728 typedef chrono::duration<rep> __secs;
2729 return time_point(__secs(__t));
2730 }
2731};
2732_LIBCPP_END_NAMESPACE_FILESYSTEM
2733#endif // !_LIBCPP_CXX03_LANG
2734
Eric Fiselierf4433a32017-05-31 22:07:49 +00002735_LIBCPP_POP_MACROS
2736
Howard Hinnantc51e1022010-05-11 19:42:16 +00002737#endif // _LIBCPP_CHRONO