NumeRe v1.1.4
NumeRe: Framework für Numerische Rechnungen
julian.h
Go to the documentation of this file.
1#ifndef JULIAN_H
2#define JULIAN_H
3
4// The MIT License (MIT)
5//
6// Copyright (c) 2016 Howard Hinnant
7//
8// Permission is hereby granted, free of charge, to any person obtaining a copy
9// of this software and associated documentation files (the "Software"), to deal
10// in the Software without restriction, including without limitation the rights
11// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12// copies of the Software, and to permit persons to whom the Software is
13// furnished to do so, subject to the following conditions:
14//
15// The above copyright notice and this permission notice shall be included in all
16// copies or substantial portions of the Software.
17//
18// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
24// SOFTWARE.
25//
26// Our apologies. When the previous paragraph was written, lowercase had not yet
27// been invented (that would involve another several millennia of evolution).
28// We did not mean to shout.
29
30#include "date.h"
31
32namespace julian
33{
34
35// durations
36
37using days = date::days;
38
39using weeks = date::weeks;
40
41using years = std::chrono::duration
42 <int, date::detail::ratio_multiply<std::ratio<1461, 4>, days::period>>;
43
44using months = std::chrono::duration
45 <int, date::detail::ratio_divide<years::period, std::ratio<12>>>;
46
47// time_point
48
49using sys_days = date::sys_days;
50using local_days = date::local_days;
51
52// types
53
54struct last_spec
55{
56 explicit last_spec() = default;
57};
58
59class day;
60class month;
61class year;
62
63class weekday;
64class weekday_indexed;
65class weekday_last;
66
67class month_day;
68class month_day_last;
69class month_weekday;
70class month_weekday_last;
71
72class year_month;
73
74class year_month_day;
75class year_month_day_last;
76class year_month_weekday;
77class year_month_weekday_last;
78
79// date composition operators
80
81CONSTCD11 year_month operator/(const year& y, const month& m) NOEXCEPT;
82CONSTCD11 year_month operator/(const year& y, int m) NOEXCEPT;
83
84CONSTCD11 month_day operator/(const day& d, const month& m) NOEXCEPT;
85CONSTCD11 month_day operator/(const day& d, int m) NOEXCEPT;
86CONSTCD11 month_day operator/(const month& m, const day& d) NOEXCEPT;
87CONSTCD11 month_day operator/(const month& m, int d) NOEXCEPT;
88CONSTCD11 month_day operator/(int m, const day& d) NOEXCEPT;
89
90CONSTCD11 month_day_last operator/(const month& m, last_spec) NOEXCEPT;
91CONSTCD11 month_day_last operator/(int m, last_spec) NOEXCEPT;
92CONSTCD11 month_day_last operator/(last_spec, const month& m) NOEXCEPT;
93CONSTCD11 month_day_last operator/(last_spec, int m) NOEXCEPT;
94
95CONSTCD11 month_weekday operator/(const month& m, const weekday_indexed& wdi) NOEXCEPT;
96CONSTCD11 month_weekday operator/(int m, const weekday_indexed& wdi) NOEXCEPT;
97CONSTCD11 month_weekday operator/(const weekday_indexed& wdi, const month& m) NOEXCEPT;
98CONSTCD11 month_weekday operator/(const weekday_indexed& wdi, int m) NOEXCEPT;
99
100CONSTCD11 month_weekday_last operator/(const month& m, const weekday_last& wdl) NOEXCEPT;
101CONSTCD11 month_weekday_last operator/(int m, const weekday_last& wdl) NOEXCEPT;
102CONSTCD11 month_weekday_last operator/(const weekday_last& wdl, const month& m) NOEXCEPT;
103CONSTCD11 month_weekday_last operator/(const weekday_last& wdl, int m) NOEXCEPT;
104
105CONSTCD11 year_month_day operator/(const year_month& ym, const day& d) NOEXCEPT;
106CONSTCD11 year_month_day operator/(const year_month& ym, int d) NOEXCEPT;
107CONSTCD11 year_month_day operator/(const year& y, const month_day& md) NOEXCEPT;
108CONSTCD11 year_month_day operator/(int y, const month_day& md) NOEXCEPT;
109CONSTCD11 year_month_day operator/(const month_day& md, const year& y) NOEXCEPT;
110CONSTCD11 year_month_day operator/(const month_day& md, int y) NOEXCEPT;
111
112CONSTCD11
113 year_month_day_last operator/(const year_month& ym, last_spec) NOEXCEPT;
114CONSTCD11
115 year_month_day_last operator/(const year& y, const month_day_last& mdl) NOEXCEPT;
116CONSTCD11
117 year_month_day_last operator/(int y, const month_day_last& mdl) NOEXCEPT;
118CONSTCD11
119 year_month_day_last operator/(const month_day_last& mdl, const year& y) NOEXCEPT;
120CONSTCD11
121 year_month_day_last operator/(const month_day_last& mdl, int y) NOEXCEPT;
122
123CONSTCD11
124year_month_weekday
125operator/(const year_month& ym, const weekday_indexed& wdi) NOEXCEPT;
126
127CONSTCD11
128year_month_weekday
129operator/(const year& y, const month_weekday& mwd) NOEXCEPT;
130
131CONSTCD11
132year_month_weekday
133operator/(int y, const month_weekday& mwd) NOEXCEPT;
134
135CONSTCD11
136year_month_weekday
137operator/(const month_weekday& mwd, const year& y) NOEXCEPT;
138
139CONSTCD11
140year_month_weekday
141operator/(const month_weekday& mwd, int y) NOEXCEPT;
142
143CONSTCD11
144year_month_weekday_last
145operator/(const year_month& ym, const weekday_last& wdl) NOEXCEPT;
146
147CONSTCD11
148year_month_weekday_last
149operator/(const year& y, const month_weekday_last& mwdl) NOEXCEPT;
150
151CONSTCD11
152year_month_weekday_last
153operator/(int y, const month_weekday_last& mwdl) NOEXCEPT;
154
155CONSTCD11
156year_month_weekday_last
157operator/(const month_weekday_last& mwdl, const year& y) NOEXCEPT;
158
159CONSTCD11
160year_month_weekday_last
161operator/(const month_weekday_last& mwdl, int y) NOEXCEPT;
162
163// Detailed interface
164
165// day
166
167class day
168{
169 unsigned char d_;
170
171public:
172 explicit CONSTCD11 day(unsigned d) NOEXCEPT;
173
174 CONSTCD14 day& operator++() NOEXCEPT;
175 CONSTCD14 day operator++(int) NOEXCEPT;
176 CONSTCD14 day& operator--() NOEXCEPT;
177 CONSTCD14 day operator--(int) NOEXCEPT;
178
179 CONSTCD14 day& operator+=(const days& d) NOEXCEPT;
180 CONSTCD14 day& operator-=(const days& d) NOEXCEPT;
181
182 CONSTCD11 explicit operator unsigned() const NOEXCEPT;
183 CONSTCD11 bool ok() const NOEXCEPT;
184};
185
186CONSTCD11 bool operator==(const day& x, const day& y) NOEXCEPT;
187CONSTCD11 bool operator!=(const day& x, const day& y) NOEXCEPT;
188CONSTCD11 bool operator< (const day& x, const day& y) NOEXCEPT;
189CONSTCD11 bool operator> (const day& x, const day& y) NOEXCEPT;
190CONSTCD11 bool operator<=(const day& x, const day& y) NOEXCEPT;
191CONSTCD11 bool operator>=(const day& x, const day& y) NOEXCEPT;
192
193CONSTCD11 day operator+(const day& x, const days& y) NOEXCEPT;
194CONSTCD11 day operator+(const days& x, const day& y) NOEXCEPT;
195CONSTCD11 day operator-(const day& x, const days& y) NOEXCEPT;
196CONSTCD11 days operator-(const day& x, const day& y) NOEXCEPT;
197
198template<class CharT, class Traits>
199std::basic_ostream<CharT, Traits>&
200operator<<(std::basic_ostream<CharT, Traits>& os, const day& d);
201
202// month
203
204class month
205{
206 unsigned char m_;
207
208public:
209 explicit CONSTCD11 month(unsigned m) NOEXCEPT;
210
211 CONSTCD14 month& operator++() NOEXCEPT;
212 CONSTCD14 month operator++(int) NOEXCEPT;
213 CONSTCD14 month& operator--() NOEXCEPT;
214 CONSTCD14 month operator--(int) NOEXCEPT;
215
216 CONSTCD14 month& operator+=(const months& m) NOEXCEPT;
217 CONSTCD14 month& operator-=(const months& m) NOEXCEPT;
218
219 CONSTCD11 explicit operator unsigned() const NOEXCEPT;
220 CONSTCD11 bool ok() const NOEXCEPT;
221};
222
223CONSTCD11 bool operator==(const month& x, const month& y) NOEXCEPT;
224CONSTCD11 bool operator!=(const month& x, const month& y) NOEXCEPT;
225CONSTCD11 bool operator< (const month& x, const month& y) NOEXCEPT;
226CONSTCD11 bool operator> (const month& x, const month& y) NOEXCEPT;
227CONSTCD11 bool operator<=(const month& x, const month& y) NOEXCEPT;
228CONSTCD11 bool operator>=(const month& x, const month& y) NOEXCEPT;
229
230CONSTCD14 month operator+(const month& x, const months& y) NOEXCEPT;
231CONSTCD14 month operator+(const months& x, const month& y) NOEXCEPT;
232CONSTCD14 month operator-(const month& x, const months& y) NOEXCEPT;
233CONSTCD14 months operator-(const month& x, const month& y) NOEXCEPT;
234
235template<class CharT, class Traits>
236std::basic_ostream<CharT, Traits>&
237operator<<(std::basic_ostream<CharT, Traits>& os, const month& m);
238
239// year
240
241class year
242{
243 short y_;
244
245public:
246 explicit CONSTCD11 year(int y) NOEXCEPT;
247
248 CONSTCD14 year& operator++() NOEXCEPT;
249 CONSTCD14 year operator++(int) NOEXCEPT;
250 CONSTCD14 year& operator--() NOEXCEPT;
251 CONSTCD14 year operator--(int) NOEXCEPT;
252
253 CONSTCD14 year& operator+=(const years& y) NOEXCEPT;
254 CONSTCD14 year& operator-=(const years& y) NOEXCEPT;
255
256 CONSTCD11 bool is_leap() const NOEXCEPT;
257
258 CONSTCD11 explicit operator int() const NOEXCEPT;
259 CONSTCD11 bool ok() const NOEXCEPT;
260
261 static CONSTCD11 year min() NOEXCEPT;
262 static CONSTCD11 year max() NOEXCEPT;
263};
264
265CONSTCD11 bool operator==(const year& x, const year& y) NOEXCEPT;
266CONSTCD11 bool operator!=(const year& x, const year& y) NOEXCEPT;
267CONSTCD11 bool operator< (const year& x, const year& y) NOEXCEPT;
268CONSTCD11 bool operator> (const year& x, const year& y) NOEXCEPT;
269CONSTCD11 bool operator<=(const year& x, const year& y) NOEXCEPT;
270CONSTCD11 bool operator>=(const year& x, const year& y) NOEXCEPT;
271
272CONSTCD11 year operator+(const year& x, const years& y) NOEXCEPT;
273CONSTCD11 year operator+(const years& x, const year& y) NOEXCEPT;
274CONSTCD11 year operator-(const year& x, const years& y) NOEXCEPT;
275CONSTCD11 years operator-(const year& x, const year& y) NOEXCEPT;
276
277template<class CharT, class Traits>
278std::basic_ostream<CharT, Traits>&
279operator<<(std::basic_ostream<CharT, Traits>& os, const year& y);
280
281// weekday
282
283class weekday
284{
285 unsigned char wd_;
286public:
287 explicit CONSTCD11 weekday(unsigned wd) NOEXCEPT;
288 explicit weekday(int) = delete;
289 CONSTCD11 weekday(const sys_days& dp) NOEXCEPT;
290 CONSTCD11 explicit weekday(const local_days& dp) NOEXCEPT;
291
292 CONSTCD14 weekday& operator++() NOEXCEPT;
293 CONSTCD14 weekday operator++(int) NOEXCEPT;
294 CONSTCD14 weekday& operator--() NOEXCEPT;
295 CONSTCD14 weekday operator--(int) NOEXCEPT;
296
297 CONSTCD14 weekday& operator+=(const days& d) NOEXCEPT;
298 CONSTCD14 weekday& operator-=(const days& d) NOEXCEPT;
299
300 CONSTCD11 explicit operator unsigned() const NOEXCEPT;
301 CONSTCD11 bool ok() const NOEXCEPT;
302
303 CONSTCD11 weekday_indexed operator[](unsigned index) const NOEXCEPT;
304 CONSTCD11 weekday_last operator[](last_spec) const NOEXCEPT;
305
306private:
307 static CONSTCD11 unsigned char weekday_from_days(int z) NOEXCEPT;
308};
309
310CONSTCD11 bool operator==(const weekday& x, const weekday& y) NOEXCEPT;
311CONSTCD11 bool operator!=(const weekday& x, const weekday& y) NOEXCEPT;
312
313CONSTCD14 weekday operator+(const weekday& x, const days& y) NOEXCEPT;
314CONSTCD14 weekday operator+(const days& x, const weekday& y) NOEXCEPT;
315CONSTCD14 weekday operator-(const weekday& x, const days& y) NOEXCEPT;
316CONSTCD14 days operator-(const weekday& x, const weekday& y) NOEXCEPT;
317
318template<class CharT, class Traits>
319std::basic_ostream<CharT, Traits>&
320operator<<(std::basic_ostream<CharT, Traits>& os, const weekday& wd);
321
322// weekday_indexed
323
324class weekday_indexed
325{
326 unsigned char wd_ : 4;
327 unsigned char index_ : 4;
328
329public:
330 CONSTCD11 weekday_indexed(const julian::weekday& wd, unsigned index) NOEXCEPT;
331
332 CONSTCD11 julian::weekday weekday() const NOEXCEPT;
333 CONSTCD11 unsigned index() const NOEXCEPT;
334 CONSTCD11 bool ok() const NOEXCEPT;
335};
336
337CONSTCD11 bool operator==(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT;
338CONSTCD11 bool operator!=(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT;
339
340template<class CharT, class Traits>
341std::basic_ostream<CharT, Traits>&
342operator<<(std::basic_ostream<CharT, Traits>& os, const weekday_indexed& wdi);
343
344// weekday_last
345
346class weekday_last
347{
348 julian::weekday wd_;
349
350public:
351 explicit CONSTCD11 weekday_last(const julian::weekday& wd) NOEXCEPT;
352
353 CONSTCD11 julian::weekday weekday() const NOEXCEPT;
354 CONSTCD11 bool ok() const NOEXCEPT;
355};
356
357CONSTCD11 bool operator==(const weekday_last& x, const weekday_last& y) NOEXCEPT;
358CONSTCD11 bool operator!=(const weekday_last& x, const weekday_last& y) NOEXCEPT;
359
360template<class CharT, class Traits>
361std::basic_ostream<CharT, Traits>&
362operator<<(std::basic_ostream<CharT, Traits>& os, const weekday_last& wdl);
363
364// year_month
365
366class year_month
367{
368 julian::year y_;
369 julian::month m_;
370
371public:
372 CONSTCD11 year_month(const julian::year& y, const julian::month& m) NOEXCEPT;
373
374 CONSTCD11 julian::year year() const NOEXCEPT;
375 CONSTCD11 julian::month month() const NOEXCEPT;
376
377 CONSTCD14 year_month& operator+=(const months& dm) NOEXCEPT;
378 CONSTCD14 year_month& operator-=(const months& dm) NOEXCEPT;
379 CONSTCD14 year_month& operator+=(const years& dy) NOEXCEPT;
380 CONSTCD14 year_month& operator-=(const years& dy) NOEXCEPT;
381
382 CONSTCD11 bool ok() const NOEXCEPT;
383};
384
385CONSTCD11 bool operator==(const year_month& x, const year_month& y) NOEXCEPT;
386CONSTCD11 bool operator!=(const year_month& x, const year_month& y) NOEXCEPT;
387CONSTCD11 bool operator< (const year_month& x, const year_month& y) NOEXCEPT;
388CONSTCD11 bool operator> (const year_month& x, const year_month& y) NOEXCEPT;
389CONSTCD11 bool operator<=(const year_month& x, const year_month& y) NOEXCEPT;
390CONSTCD11 bool operator>=(const year_month& x, const year_month& y) NOEXCEPT;
391
392CONSTCD14 year_month operator+(const year_month& ym, const months& dm) NOEXCEPT;
393CONSTCD14 year_month operator+(const months& dm, const year_month& ym) NOEXCEPT;
394CONSTCD14 year_month operator-(const year_month& ym, const months& dm) NOEXCEPT;
395
396CONSTCD11 months operator-(const year_month& x, const year_month& y) NOEXCEPT;
397CONSTCD11 year_month operator+(const year_month& ym, const years& dy) NOEXCEPT;
398CONSTCD11 year_month operator+(const years& dy, const year_month& ym) NOEXCEPT;
399CONSTCD11 year_month operator-(const year_month& ym, const years& dy) NOEXCEPT;
400
401template<class CharT, class Traits>
402std::basic_ostream<CharT, Traits>&
403operator<<(std::basic_ostream<CharT, Traits>& os, const year_month& ym);
404
405// month_day
406
407class month_day
408{
409 julian::month m_;
410 julian::day d_;
411
412public:
413 CONSTCD11 month_day(const julian::month& m, const julian::day& d) NOEXCEPT;
414
415 CONSTCD11 julian::month month() const NOEXCEPT;
416 CONSTCD11 julian::day day() const NOEXCEPT;
417
418 CONSTCD14 bool ok() const NOEXCEPT;
419};
420
421CONSTCD11 bool operator==(const month_day& x, const month_day& y) NOEXCEPT;
422CONSTCD11 bool operator!=(const month_day& x, const month_day& y) NOEXCEPT;
423CONSTCD11 bool operator< (const month_day& x, const month_day& y) NOEXCEPT;
424CONSTCD11 bool operator> (const month_day& x, const month_day& y) NOEXCEPT;
425CONSTCD11 bool operator<=(const month_day& x, const month_day& y) NOEXCEPT;
426CONSTCD11 bool operator>=(const month_day& x, const month_day& y) NOEXCEPT;
427
428template<class CharT, class Traits>
429std::basic_ostream<CharT, Traits>&
430operator<<(std::basic_ostream<CharT, Traits>& os, const month_day& md);
431
432// month_day_last
433
434class month_day_last
435{
436 julian::month m_;
437
438public:
439 CONSTCD11 explicit month_day_last(const julian::month& m) NOEXCEPT;
440
441 CONSTCD11 julian::month month() const NOEXCEPT;
442 CONSTCD11 bool ok() const NOEXCEPT;
443};
444
445CONSTCD11 bool operator==(const month_day_last& x, const month_day_last& y) NOEXCEPT;
446CONSTCD11 bool operator!=(const month_day_last& x, const month_day_last& y) NOEXCEPT;
447CONSTCD11 bool operator< (const month_day_last& x, const month_day_last& y) NOEXCEPT;
448CONSTCD11 bool operator> (const month_day_last& x, const month_day_last& y) NOEXCEPT;
449CONSTCD11 bool operator<=(const month_day_last& x, const month_day_last& y) NOEXCEPT;
450CONSTCD11 bool operator>=(const month_day_last& x, const month_day_last& y) NOEXCEPT;
451
452template<class CharT, class Traits>
453std::basic_ostream<CharT, Traits>&
454operator<<(std::basic_ostream<CharT, Traits>& os, const month_day_last& mdl);
455
456// month_weekday
457
458class month_weekday
459{
460 julian::month m_;
461 julian::weekday_indexed wdi_;
462public:
463 CONSTCD11 month_weekday(const julian::month& m,
464 const julian::weekday_indexed& wdi) NOEXCEPT;
465
466 CONSTCD11 julian::month month() const NOEXCEPT;
467 CONSTCD11 julian::weekday_indexed weekday_indexed() const NOEXCEPT;
468
469 CONSTCD11 bool ok() const NOEXCEPT;
470};
471
472CONSTCD11 bool operator==(const month_weekday& x, const month_weekday& y) NOEXCEPT;
473CONSTCD11 bool operator!=(const month_weekday& x, const month_weekday& y) NOEXCEPT;
474
475template<class CharT, class Traits>
476std::basic_ostream<CharT, Traits>&
477operator<<(std::basic_ostream<CharT, Traits>& os, const month_weekday& mwd);
478
479// month_weekday_last
480
481class month_weekday_last
482{
483 julian::month m_;
484 julian::weekday_last wdl_;
485
486public:
487 CONSTCD11 month_weekday_last(const julian::month& m,
488 const julian::weekday_last& wd) NOEXCEPT;
489
490 CONSTCD11 julian::month month() const NOEXCEPT;
491 CONSTCD11 julian::weekday_last weekday_last() const NOEXCEPT;
492
493 CONSTCD11 bool ok() const NOEXCEPT;
494};
495
496CONSTCD11
497 bool operator==(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT;
498CONSTCD11
499 bool operator!=(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT;
500
501template<class CharT, class Traits>
502std::basic_ostream<CharT, Traits>&
503operator<<(std::basic_ostream<CharT, Traits>& os, const month_weekday_last& mwdl);
504
505// class year_month_day
506
507class year_month_day
508{
509 julian::year y_;
510 julian::month m_;
511 julian::day d_;
512
513public:
514 CONSTCD11 year_month_day(const julian::year& y, const julian::month& m,
515 const julian::day& d) NOEXCEPT;
516 CONSTCD14 year_month_day(const year_month_day_last& ymdl) NOEXCEPT;
517
518 CONSTCD14 year_month_day(sys_days dp) NOEXCEPT;
519 CONSTCD14 explicit year_month_day(local_days dp) NOEXCEPT;
520
521 CONSTCD14 year_month_day& operator+=(const months& m) NOEXCEPT;
522 CONSTCD14 year_month_day& operator-=(const months& m) NOEXCEPT;
523 CONSTCD14 year_month_day& operator+=(const years& y) NOEXCEPT;
524 CONSTCD14 year_month_day& operator-=(const years& y) NOEXCEPT;
525
526 CONSTCD11 julian::year year() const NOEXCEPT;
527 CONSTCD11 julian::month month() const NOEXCEPT;
528 CONSTCD11 julian::day day() const NOEXCEPT;
529
530 CONSTCD14 operator sys_days() const NOEXCEPT;
531 CONSTCD14 explicit operator local_days() const NOEXCEPT;
532 CONSTCD14 bool ok() const NOEXCEPT;
533
534private:
535 static CONSTCD14 year_month_day from_days(days dp) NOEXCEPT;
536 CONSTCD14 days to_days() const NOEXCEPT;
537};
538
539CONSTCD11 bool operator==(const year_month_day& x, const year_month_day& y) NOEXCEPT;
540CONSTCD11 bool operator!=(const year_month_day& x, const year_month_day& y) NOEXCEPT;
541CONSTCD11 bool operator< (const year_month_day& x, const year_month_day& y) NOEXCEPT;
542CONSTCD11 bool operator> (const year_month_day& x, const year_month_day& y) NOEXCEPT;
543CONSTCD11 bool operator<=(const year_month_day& x, const year_month_day& y) NOEXCEPT;
544CONSTCD11 bool operator>=(const year_month_day& x, const year_month_day& y) NOEXCEPT;
545
546CONSTCD14 year_month_day operator+(const year_month_day& ymd, const months& dm) NOEXCEPT;
547CONSTCD14 year_month_day operator+(const months& dm, const year_month_day& ymd) NOEXCEPT;
548CONSTCD14 year_month_day operator-(const year_month_day& ymd, const months& dm) NOEXCEPT;
549CONSTCD11 year_month_day operator+(const year_month_day& ymd, const years& dy) NOEXCEPT;
550CONSTCD11 year_month_day operator+(const years& dy, const year_month_day& ymd) NOEXCEPT;
551CONSTCD11 year_month_day operator-(const year_month_day& ymd, const years& dy) NOEXCEPT;
552
553template<class CharT, class Traits>
554std::basic_ostream<CharT, Traits>&
555operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day& ymd);
556
557// year_month_day_last
558
559class year_month_day_last
560{
561 julian::year y_;
562 julian::month_day_last mdl_;
563
564public:
565 CONSTCD11 year_month_day_last(const julian::year& y,
566 const julian::month_day_last& mdl) NOEXCEPT;
567
568 CONSTCD14 year_month_day_last& operator+=(const months& m) NOEXCEPT;
569 CONSTCD14 year_month_day_last& operator-=(const months& m) NOEXCEPT;
570 CONSTCD14 year_month_day_last& operator+=(const years& y) NOEXCEPT;
571 CONSTCD14 year_month_day_last& operator-=(const years& y) NOEXCEPT;
572
573 CONSTCD11 julian::year year() const NOEXCEPT;
574 CONSTCD11 julian::month month() const NOEXCEPT;
575 CONSTCD11 julian::month_day_last month_day_last() const NOEXCEPT;
576 CONSTCD14 julian::day day() const NOEXCEPT;
577
578 CONSTCD14 operator sys_days() const NOEXCEPT;
579 CONSTCD14 explicit operator local_days() const NOEXCEPT;
580 CONSTCD11 bool ok() const NOEXCEPT;
581};
582
583CONSTCD11
584 bool operator==(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
585CONSTCD11
586 bool operator!=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
587CONSTCD11
588 bool operator< (const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
589CONSTCD11
590 bool operator> (const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
591CONSTCD11
592 bool operator<=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
593CONSTCD11
594 bool operator>=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;
595
596CONSTCD14
597year_month_day_last
598operator+(const year_month_day_last& ymdl, const months& dm) NOEXCEPT;
599
600CONSTCD14
601year_month_day_last
602operator+(const months& dm, const year_month_day_last& ymdl) NOEXCEPT;
603
604CONSTCD11
605year_month_day_last
606operator+(const year_month_day_last& ymdl, const years& dy) NOEXCEPT;
607
608CONSTCD11
609year_month_day_last
610operator+(const years& dy, const year_month_day_last& ymdl) NOEXCEPT;
611
612CONSTCD14
613year_month_day_last
614operator-(const year_month_day_last& ymdl, const months& dm) NOEXCEPT;
615
616CONSTCD11
617year_month_day_last
618operator-(const year_month_day_last& ymdl, const years& dy) NOEXCEPT;
619
620template<class CharT, class Traits>
621std::basic_ostream<CharT, Traits>&
622operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day_last& ymdl);
623
624// year_month_weekday
625
626class year_month_weekday
627{
628 julian::year y_;
629 julian::month m_;
630 julian::weekday_indexed wdi_;
631
632public:
633 CONSTCD11 year_month_weekday(const julian::year& y, const julian::month& m,
634 const julian::weekday_indexed& wdi) NOEXCEPT;
635 CONSTCD14 year_month_weekday(const sys_days& dp) NOEXCEPT;
636 CONSTCD14 explicit year_month_weekday(const local_days& dp) NOEXCEPT;
637
638 CONSTCD14 year_month_weekday& operator+=(const months& m) NOEXCEPT;
639 CONSTCD14 year_month_weekday& operator-=(const months& m) NOEXCEPT;
640 CONSTCD14 year_month_weekday& operator+=(const years& y) NOEXCEPT;
641 CONSTCD14 year_month_weekday& operator-=(const years& y) NOEXCEPT;
642
643 CONSTCD11 julian::year year() const NOEXCEPT;
644 CONSTCD11 julian::month month() const NOEXCEPT;
645 CONSTCD11 julian::weekday weekday() const NOEXCEPT;
646 CONSTCD11 unsigned index() const NOEXCEPT;
647 CONSTCD11 julian::weekday_indexed weekday_indexed() const NOEXCEPT;
648
649 CONSTCD14 operator sys_days() const NOEXCEPT;
650 CONSTCD14 explicit operator local_days() const NOEXCEPT;
651 CONSTCD14 bool ok() const NOEXCEPT;
652
653private:
654 static CONSTCD14 year_month_weekday from_days(days dp) NOEXCEPT;
655 CONSTCD14 days to_days() const NOEXCEPT;
656};
657
658CONSTCD11
659 bool operator==(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT;
660CONSTCD11
661 bool operator!=(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT;
662
663CONSTCD14
664year_month_weekday
665operator+(const year_month_weekday& ymwd, const months& dm) NOEXCEPT;
666
667CONSTCD14
668year_month_weekday
669operator+(const months& dm, const year_month_weekday& ymwd) NOEXCEPT;
670
671CONSTCD11
672year_month_weekday
673operator+(const year_month_weekday& ymwd, const years& dy) NOEXCEPT;
674
675CONSTCD11
676year_month_weekday
677operator+(const years& dy, const year_month_weekday& ymwd) NOEXCEPT;
678
679CONSTCD14
680year_month_weekday
681operator-(const year_month_weekday& ymwd, const months& dm) NOEXCEPT;
682
683CONSTCD11
684year_month_weekday
685operator-(const year_month_weekday& ymwd, const years& dy) NOEXCEPT;
686
687template<class CharT, class Traits>
688std::basic_ostream<CharT, Traits>&
689operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday& ymwdi);
690
691// year_month_weekday_last
692
693class year_month_weekday_last
694{
695 julian::year y_;
696 julian::month m_;
697 julian::weekday_last wdl_;
698
699public:
700 CONSTCD11 year_month_weekday_last(const julian::year& y, const julian::month& m,
701 const julian::weekday_last& wdl) NOEXCEPT;
702
703 CONSTCD14 year_month_weekday_last& operator+=(const months& m) NOEXCEPT;
704 CONSTCD14 year_month_weekday_last& operator-=(const months& m) NOEXCEPT;
705 CONSTCD14 year_month_weekday_last& operator+=(const years& y) NOEXCEPT;
706 CONSTCD14 year_month_weekday_last& operator-=(const years& y) NOEXCEPT;
707
708 CONSTCD11 julian::year year() const NOEXCEPT;
709 CONSTCD11 julian::month month() const NOEXCEPT;
710 CONSTCD11 julian::weekday weekday() const NOEXCEPT;
711 CONSTCD11 julian::weekday_last weekday_last() const NOEXCEPT;
712
713 CONSTCD14 operator sys_days() const NOEXCEPT;
714 CONSTCD14 explicit operator local_days() const NOEXCEPT;
715 CONSTCD11 bool ok() const NOEXCEPT;
716
717private:
718 CONSTCD14 days to_days() const NOEXCEPT;
719};
720
721CONSTCD11
722bool
723operator==(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT;
724
725CONSTCD11
726bool
727operator!=(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT;
728
729CONSTCD14
730year_month_weekday_last
731operator+(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT;
732
733CONSTCD14
734year_month_weekday_last
735operator+(const months& dm, const year_month_weekday_last& ymwdl) NOEXCEPT;
736
737CONSTCD11
738year_month_weekday_last
739operator+(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT;
740
741CONSTCD11
742year_month_weekday_last
743operator+(const years& dy, const year_month_weekday_last& ymwdl) NOEXCEPT;
744
745CONSTCD14
746year_month_weekday_last
747operator-(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT;
748
749CONSTCD11
750year_month_weekday_last
751operator-(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT;
752
753template<class CharT, class Traits>
754std::basic_ostream<CharT, Traits>&
755operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday_last& ymwdl);
756
757#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
758inline namespace literals
759{
760
761CONSTCD11 julian::day operator "" _d(unsigned long long d) NOEXCEPT;
762CONSTCD11 julian::year operator "" _y(unsigned long long y) NOEXCEPT;
763
764// CONSTDATA julian::month jan{1};
765// CONSTDATA julian::month feb{2};
766// CONSTDATA julian::month mar{3};
767// CONSTDATA julian::month apr{4};
768// CONSTDATA julian::month may{5};
769// CONSTDATA julian::month jun{6};
770// CONSTDATA julian::month jul{7};
771// CONSTDATA julian::month aug{8};
772// CONSTDATA julian::month sep{9};
773// CONSTDATA julian::month oct{10};
774// CONSTDATA julian::month nov{11};
775// CONSTDATA julian::month dec{12};
776
777} // inline namespace literals
778#endif // !defined(_MSC_VER) || (_MSC_VER >= 1900)
779
780//----------------+
781// Implementation |
782//----------------+
783
784// day
785
786CONSTCD11 inline day::day(unsigned d) NOEXCEPT : d_(static_cast<unsigned char>(d)) {}
787CONSTCD14 inline day& day::operator++() NOEXCEPT {++d_; return *this;}
788CONSTCD14 inline day day::operator++(int) NOEXCEPT {auto tmp(*this); ++(*this); return tmp;}
789CONSTCD14 inline day& day::operator--() NOEXCEPT {--d_; return *this;}
790CONSTCD14 inline day day::operator--(int) NOEXCEPT {auto tmp(*this); --(*this); return tmp;}
791CONSTCD14 inline day& day::operator+=(const days& d) NOEXCEPT {*this = *this + d; return *this;}
792CONSTCD14 inline day& day::operator-=(const days& d) NOEXCEPT {*this = *this - d; return *this;}
793CONSTCD11 inline day::operator unsigned() const NOEXCEPT {return d_;}
794CONSTCD11 inline bool day::ok() const NOEXCEPT {return 1 <= d_ && d_ <= 31;}
795
796CONSTCD11
797inline
798bool
799operator==(const day& x, const day& y) NOEXCEPT
800{
801 return static_cast<unsigned>(x) == static_cast<unsigned>(y);
802}
803
804CONSTCD11
805inline
806bool
807operator!=(const day& x, const day& y) NOEXCEPT
808{
809 return !(x == y);
810}
811
812CONSTCD11
813inline
814bool
815operator<(const day& x, const day& y) NOEXCEPT
816{
817 return static_cast<unsigned>(x) < static_cast<unsigned>(y);
818}
819
820CONSTCD11
821inline
822bool
823operator>(const day& x, const day& y) NOEXCEPT
824{
825 return y < x;
826}
827
828CONSTCD11
829inline
830bool
831operator<=(const day& x, const day& y) NOEXCEPT
832{
833 return !(y < x);
834}
835
836CONSTCD11
837inline
838bool
839operator>=(const day& x, const day& y) NOEXCEPT
840{
841 return !(x < y);
842}
843
844CONSTCD11
845inline
846days
847operator-(const day& x, const day& y) NOEXCEPT
848{
849 return days{static_cast<days::rep>(static_cast<unsigned>(x)
850 - static_cast<unsigned>(y))};
851}
852
853CONSTCD11
854inline
855day
856operator+(const day& x, const days& y) NOEXCEPT
857{
858 return day{static_cast<unsigned>(x) + static_cast<unsigned>(y.count())};
859}
860
861CONSTCD11
862inline
863day
864operator+(const days& x, const day& y) NOEXCEPT
865{
866 return y + x;
867}
868
869CONSTCD11
870inline
871day
872operator-(const day& x, const days& y) NOEXCEPT
873{
874 return x + -y;
875}
876
877template<class CharT, class Traits>
878inline
879std::basic_ostream<CharT, Traits>&
880operator<<(std::basic_ostream<CharT, Traits>& os, const day& d)
881{
882 date::detail::save_ostream<CharT, Traits> _(os);
883 os.fill('0');
884 os.flags(std::ios::dec | std::ios::right);
885 os.width(2);
886 os << static_cast<unsigned>(d);
887 return os;
888}
889
890// month
891
892CONSTCD11 inline month::month(unsigned m) NOEXCEPT : m_(static_cast<decltype(m_)>(m)) {}
893CONSTCD14 inline month& month::operator++() NOEXCEPT {if (++m_ == 13) m_ = 1; return *this;}
894CONSTCD14 inline month month::operator++(int) NOEXCEPT {auto tmp(*this); ++(*this); return tmp;}
895CONSTCD14 inline month& month::operator--() NOEXCEPT {if (--m_ == 0) m_ = 12; return *this;}
896CONSTCD14 inline month month::operator--(int) NOEXCEPT {auto tmp(*this); --(*this); return tmp;}
897
898CONSTCD14
899inline
900month&
901month::operator+=(const months& m) NOEXCEPT
902{
903 *this = *this + m;
904 return *this;
905}
906
907CONSTCD14
908inline
909month&
910month::operator-=(const months& m) NOEXCEPT
911{
912 *this = *this - m;
913 return *this;
914}
915
916CONSTCD11 inline month::operator unsigned() const NOEXCEPT {return m_;}
917CONSTCD11 inline bool month::ok() const NOEXCEPT {return 1 <= m_ && m_ <= 12;}
918
919CONSTCD11
920inline
921bool
922operator==(const month& x, const month& y) NOEXCEPT
923{
924 return static_cast<unsigned>(x) == static_cast<unsigned>(y);
925}
926
927CONSTCD11
928inline
929bool
930operator!=(const month& x, const month& y) NOEXCEPT
931{
932 return !(x == y);
933}
934
935CONSTCD11
936inline
937bool
938operator<(const month& x, const month& y) NOEXCEPT
939{
940 return static_cast<unsigned>(x) < static_cast<unsigned>(y);
941}
942
943CONSTCD11
944inline
945bool
946operator>(const month& x, const month& y) NOEXCEPT
947{
948 return y < x;
949}
950
951CONSTCD11
952inline
953bool
954operator<=(const month& x, const month& y) NOEXCEPT
955{
956 return !(y < x);
957}
958
959CONSTCD11
960inline
961bool
962operator>=(const month& x, const month& y) NOEXCEPT
963{
964 return !(x < y);
965}
966
967CONSTCD14
968inline
969months
970operator-(const month& x, const month& y) NOEXCEPT
971{
972 auto const d = static_cast<unsigned>(x) - static_cast<unsigned>(y);
973 return months(d <= 11 ? d : d + 12);
974}
975
976CONSTCD14
977inline
978month
979operator+(const month& x, const months& y) NOEXCEPT
980{
981 auto const mu = static_cast<long long>(static_cast<unsigned>(x)) - 1 + y.count();
982 auto const yr = (mu >= 0 ? mu : mu-11) / 12;
983 return month{static_cast<unsigned>(mu - yr * 12 + 1)};
984}
985
986CONSTCD14
987inline
988month
989operator+(const months& x, const month& y) NOEXCEPT
990{
991 return y + x;
992}
993
994CONSTCD14
995inline
996month
997operator-(const month& x, const months& y) NOEXCEPT
998{
999 return x + -y;
1000}
1001
1002template<class CharT, class Traits>
1003inline
1004std::basic_ostream<CharT, Traits>&
1005operator<<(std::basic_ostream<CharT, Traits>& os, const month& m)
1006{
1007 switch (static_cast<unsigned>(m))
1008 {
1009 case 1:
1010 os << "Jan";
1011 break;
1012 case 2:
1013 os << "Feb";
1014 break;
1015 case 3:
1016 os << "Mar";
1017 break;
1018 case 4:
1019 os << "Apr";
1020 break;
1021 case 5:
1022 os << "May";
1023 break;
1024 case 6:
1025 os << "Jun";
1026 break;
1027 case 7:
1028 os << "Jul";
1029 break;
1030 case 8:
1031 os << "Aug";
1032 break;
1033 case 9:
1034 os << "Sep";
1035 break;
1036 case 10:
1037 os << "Oct";
1038 break;
1039 case 11:
1040 os << "Nov";
1041 break;
1042 case 12:
1043 os << "Dec";
1044 break;
1045 default:
1046 os << static_cast<unsigned>(m) << " is not a valid month";
1047 break;
1048 }
1049 return os;
1050}
1051
1052// year
1053
1054CONSTCD11 inline year::year(int y) NOEXCEPT : y_(static_cast<decltype(y_)>(y)) {}
1055CONSTCD14 inline year& year::operator++() NOEXCEPT {++y_; return *this;}
1056CONSTCD14 inline year year::operator++(int) NOEXCEPT {auto tmp(*this); ++(*this); return tmp;}
1057CONSTCD14 inline year& year::operator--() NOEXCEPT {--y_; return *this;}
1058CONSTCD14 inline year year::operator--(int) NOEXCEPT {auto tmp(*this); --(*this); return tmp;}
1059CONSTCD14 inline year& year::operator+=(const years& y) NOEXCEPT {*this = *this + y; return *this;}
1060CONSTCD14 inline year& year::operator-=(const years& y) NOEXCEPT {*this = *this - y; return *this;}
1061
1062CONSTCD11
1063inline
1064bool
1065year::is_leap() const NOEXCEPT
1066{
1067 return y_ % 4 == 0;
1068}
1069
1070CONSTCD11 inline year::operator int() const NOEXCEPT {return y_;}
1071CONSTCD11 inline bool year::ok() const NOEXCEPT {return true;}
1072
1073CONSTCD11
1074inline
1075year
1076year::min() NOEXCEPT
1077{
1078 return year{std::numeric_limits<short>::min()};
1079}
1080
1081CONSTCD11
1082inline
1083year
1084year::max() NOEXCEPT
1085{
1086 return year{std::numeric_limits<short>::max()};
1087}
1088
1089CONSTCD11
1090inline
1091bool
1092operator==(const year& x, const year& y) NOEXCEPT
1093{
1094 return static_cast<int>(x) == static_cast<int>(y);
1095}
1096
1097CONSTCD11
1098inline
1099bool
1100operator!=(const year& x, const year& y) NOEXCEPT
1101{
1102 return !(x == y);
1103}
1104
1105CONSTCD11
1106inline
1107bool
1108operator<(const year& x, const year& y) NOEXCEPT
1109{
1110 return static_cast<int>(x) < static_cast<int>(y);
1111}
1112
1113CONSTCD11
1114inline
1115bool
1116operator>(const year& x, const year& y) NOEXCEPT
1117{
1118 return y < x;
1119}
1120
1121CONSTCD11
1122inline
1123bool
1124operator<=(const year& x, const year& y) NOEXCEPT
1125{
1126 return !(y < x);
1127}
1128
1129CONSTCD11
1130inline
1131bool
1132operator>=(const year& x, const year& y) NOEXCEPT
1133{
1134 return !(x < y);
1135}
1136
1137CONSTCD11
1138inline
1139years
1140operator-(const year& x, const year& y) NOEXCEPT
1141{
1142 return years{static_cast<int>(x) - static_cast<int>(y)};
1143}
1144
1145CONSTCD11
1146inline
1147year
1148operator+(const year& x, const years& y) NOEXCEPT
1149{
1150 return year{static_cast<int>(x) + y.count()};
1151}
1152
1153CONSTCD11
1154inline
1155year
1156operator+(const years& x, const year& y) NOEXCEPT
1157{
1158 return y + x;
1159}
1160
1161CONSTCD11
1162inline
1163year
1164operator-(const year& x, const years& y) NOEXCEPT
1165{
1166 return year{static_cast<int>(x) - y.count()};
1167}
1168
1169template<class CharT, class Traits>
1170inline
1171std::basic_ostream<CharT, Traits>&
1172operator<<(std::basic_ostream<CharT, Traits>& os, const year& y)
1173{
1174 date::detail::save_ostream<CharT, Traits> _(os);
1175 os.fill('0');
1176 os.flags(std::ios::dec | std::ios::internal);
1177 os.width(4 + (y < year{0}));
1178 os << static_cast<int>(y);
1179 return os;
1180}
1181
1182// weekday
1183
1184CONSTCD11
1185inline
1186unsigned char
1187weekday::weekday_from_days(int z) NOEXCEPT
1188{
1189 return static_cast<unsigned char>(static_cast<unsigned>(
1190 z >= -4 ? (z+4) % 7 : (z+5) % 7 + 6));
1191}
1192
1193CONSTCD11
1194inline
1195weekday::weekday(unsigned wd) NOEXCEPT
1196 : wd_(static_cast<decltype(wd_)>(wd))
1197 {}
1198
1199CONSTCD11
1200inline
1201weekday::weekday(const sys_days& dp) NOEXCEPT
1202 : wd_(weekday_from_days(dp.time_since_epoch().count()))
1203 {}
1204
1205CONSTCD11
1206inline
1207weekday::weekday(const local_days& dp) NOEXCEPT
1208 : wd_(weekday_from_days(dp.time_since_epoch().count()))
1209 {}
1210
1211CONSTCD14 inline weekday& weekday::operator++() NOEXCEPT {if (++wd_ == 7) wd_ = 0; return *this;}
1212CONSTCD14 inline weekday weekday::operator++(int) NOEXCEPT {auto tmp(*this); ++(*this); return tmp;}
1213CONSTCD14 inline weekday& weekday::operator--() NOEXCEPT {if (wd_-- == 0) wd_ = 6; return *this;}
1214CONSTCD14 inline weekday weekday::operator--(int) NOEXCEPT {auto tmp(*this); --(*this); return tmp;}
1215
1216CONSTCD14
1217inline
1218weekday&
1219weekday::operator+=(const days& d) NOEXCEPT
1220{
1221 *this = *this + d;
1222 return *this;
1223}
1224
1225CONSTCD14
1226inline
1227weekday&
1228weekday::operator-=(const days& d) NOEXCEPT
1229{
1230 *this = *this - d;
1231 return *this;
1232}
1233
1234CONSTCD11
1235inline
1236weekday::operator unsigned() const NOEXCEPT
1237{
1238 return static_cast<unsigned>(wd_);
1239}
1240
1241CONSTCD11 inline bool weekday::ok() const NOEXCEPT {return wd_ <= 6;}
1242
1243CONSTCD11
1244inline
1245bool
1246operator==(const weekday& x, const weekday& y) NOEXCEPT
1247{
1248 return static_cast<unsigned>(x) == static_cast<unsigned>(y);
1249}
1250
1251CONSTCD11
1252inline
1253bool
1254operator!=(const weekday& x, const weekday& y) NOEXCEPT
1255{
1256 return !(x == y);
1257}
1258
1259CONSTCD14
1260inline
1261days
1262operator-(const weekday& x, const weekday& y) NOEXCEPT
1263{
1264 auto const diff = static_cast<unsigned>(x) - static_cast<unsigned>(y);
1265 return days{diff <= 6 ? diff : diff + 7};
1266}
1267
1268CONSTCD14
1269inline
1270weekday
1271operator+(const weekday& x, const days& y) NOEXCEPT
1272{
1273 auto const wdu = static_cast<long long>(static_cast<unsigned>(x)) + y.count();
1274 auto const wk = (wdu >= 0 ? wdu : wdu-6) / 7;
1275 return weekday{static_cast<unsigned>(wdu - wk * 7)};
1276}
1277
1278CONSTCD14
1279inline
1280weekday
1281operator+(const days& x, const weekday& y) NOEXCEPT
1282{
1283 return y + x;
1284}
1285
1286CONSTCD14
1287inline
1288weekday
1289operator-(const weekday& x, const days& y) NOEXCEPT
1290{
1291 return x + -y;
1292}
1293
1294template<class CharT, class Traits>
1295inline
1296std::basic_ostream<CharT, Traits>&
1297operator<<(std::basic_ostream<CharT, Traits>& os, const weekday& wd)
1298{
1299 switch (static_cast<unsigned>(wd))
1300 {
1301 case 0:
1302 os << "Sun";
1303 break;
1304 case 1:
1305 os << "Mon";
1306 break;
1307 case 2:
1308 os << "Tue";
1309 break;
1310 case 3:
1311 os << "Wed";
1312 break;
1313 case 4:
1314 os << "Thu";
1315 break;
1316 case 5:
1317 os << "Fri";
1318 break;
1319 case 6:
1320 os << "Sat";
1321 break;
1322 default:
1323 os << static_cast<unsigned>(wd) << " is not a valid weekday";
1324 break;
1325 }
1326 return os;
1327}
1328
1329#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
1330inline namespace literals
1331{
1332
1333CONSTCD11
1334inline
1335julian::day
1336operator "" _d(unsigned long long d) NOEXCEPT
1337{
1338 return julian::day{static_cast<unsigned>(d)};
1339}
1340
1341CONSTCD11
1342inline
1343julian::year
1344operator "" _y(unsigned long long y) NOEXCEPT
1345{
1346 return julian::year(static_cast<int>(y));
1347}
1348#endif // !defined(_MSC_VER) || (_MSC_VER >= 1900)
1349
1350CONSTDATA julian::last_spec last{};
1351
1352CONSTDATA julian::month jan{1};
1353CONSTDATA julian::month feb{2};
1354CONSTDATA julian::month mar{3};
1355CONSTDATA julian::month apr{4};
1356CONSTDATA julian::month may{5};
1357CONSTDATA julian::month jun{6};
1358CONSTDATA julian::month jul{7};
1359CONSTDATA julian::month aug{8};
1360CONSTDATA julian::month sep{9};
1361CONSTDATA julian::month oct{10};
1362CONSTDATA julian::month nov{11};
1363CONSTDATA julian::month dec{12};
1364
1365CONSTDATA julian::weekday sun{0u};
1366CONSTDATA julian::weekday mon{1u};
1367CONSTDATA julian::weekday tue{2u};
1368CONSTDATA julian::weekday wed{3u};
1369CONSTDATA julian::weekday thu{4u};
1370CONSTDATA julian::weekday fri{5u};
1371CONSTDATA julian::weekday sat{6u};
1372
1373#if !defined(_MSC_VER) || (_MSC_VER >= 1900)
1374} // inline namespace literals
1375#endif
1376
1377// weekday_indexed
1378
1379CONSTCD11
1380inline
1381weekday
1382weekday_indexed::weekday() const NOEXCEPT
1383{
1384 return julian::weekday{static_cast<unsigned>(wd_)};
1385}
1386
1387CONSTCD11 inline unsigned weekday_indexed::index() const NOEXCEPT {return index_;}
1388
1389CONSTCD11
1390inline
1391bool
1392weekday_indexed::ok() const NOEXCEPT
1393{
1394 return weekday().ok() && 1 <= index_ && index_ <= 5;
1395}
1396
1397CONSTCD11
1398inline
1399weekday_indexed::weekday_indexed(const julian::weekday& wd, unsigned index) NOEXCEPT
1400 : wd_(static_cast<decltype(wd_)>(static_cast<unsigned>(wd)))
1401 , index_(static_cast<decltype(index_)>(index))
1402 {}
1403
1404template<class CharT, class Traits>
1405inline
1406std::basic_ostream<CharT, Traits>&
1407operator<<(std::basic_ostream<CharT, Traits>& os, const weekday_indexed& wdi)
1408{
1409 return os << wdi.weekday() << '[' << wdi.index() << ']';
1410}
1411
1412CONSTCD11
1413inline
1414weekday_indexed
1415weekday::operator[](unsigned index) const NOEXCEPT
1416{
1417 return {*this, index};
1418}
1419
1420CONSTCD11
1421inline
1422bool
1423operator==(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT
1424{
1425 return x.weekday() == y.weekday() && x.index() == y.index();
1426}
1427
1428CONSTCD11
1429inline
1430bool
1431operator!=(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT
1432{
1433 return !(x == y);
1434}
1435
1436// weekday_last
1437
1438CONSTCD11 inline julian::weekday weekday_last::weekday() const NOEXCEPT {return wd_;}
1439CONSTCD11 inline bool weekday_last::ok() const NOEXCEPT {return wd_.ok();}
1440CONSTCD11 inline weekday_last::weekday_last(const julian::weekday& wd) NOEXCEPT : wd_(wd) {}
1441
1442CONSTCD11
1443inline
1444bool
1445operator==(const weekday_last& x, const weekday_last& y) NOEXCEPT
1446{
1447 return x.weekday() == y.weekday();
1448}
1449
1450CONSTCD11
1451inline
1452bool
1453operator!=(const weekday_last& x, const weekday_last& y) NOEXCEPT
1454{
1455 return !(x == y);
1456}
1457
1458template<class CharT, class Traits>
1459inline
1460std::basic_ostream<CharT, Traits>&
1461operator<<(std::basic_ostream<CharT, Traits>& os, const weekday_last& wdl)
1462{
1463 return os << wdl.weekday() << "[last]";
1464}
1465
1466CONSTCD11
1467inline
1468weekday_last
1469weekday::operator[](last_spec) const NOEXCEPT
1470{
1471 return weekday_last{*this};
1472}
1473
1474// year_month
1475
1476CONSTCD11
1477inline
1478year_month::year_month(const julian::year& y, const julian::month& m) NOEXCEPT
1479 : y_(y)
1480 , m_(m)
1481 {}
1482
1483CONSTCD11 inline year year_month::year() const NOEXCEPT {return y_;}
1484CONSTCD11 inline month year_month::month() const NOEXCEPT {return m_;}
1485CONSTCD11 inline bool year_month::ok() const NOEXCEPT {return y_.ok() && m_.ok();}
1486
1487CONSTCD14
1488inline
1489year_month&
1490year_month::operator+=(const months& dm) NOEXCEPT
1491{
1492 *this = *this + dm;
1493 return *this;
1494}
1495
1496CONSTCD14
1497inline
1498year_month&
1499year_month::operator-=(const months& dm) NOEXCEPT
1500{
1501 *this = *this - dm;
1502 return *this;
1503}
1504
1505CONSTCD14
1506inline
1507year_month&
1508year_month::operator+=(const years& dy) NOEXCEPT
1509{
1510 *this = *this + dy;
1511 return *this;
1512}
1513
1514CONSTCD14
1515inline
1516year_month&
1517year_month::operator-=(const years& dy) NOEXCEPT
1518{
1519 *this = *this - dy;
1520 return *this;
1521}
1522
1523CONSTCD11
1524inline
1525bool
1526operator==(const year_month& x, const year_month& y) NOEXCEPT
1527{
1528 return x.year() == y.year() && x.month() == y.month();
1529}
1530
1531CONSTCD11
1532inline
1533bool
1534operator!=(const year_month& x, const year_month& y) NOEXCEPT
1535{
1536 return !(x == y);
1537}
1538
1539CONSTCD11
1540inline
1541bool
1542operator<(const year_month& x, const year_month& y) NOEXCEPT
1543{
1544 return x.year() < y.year() ? true
1545 : (x.year() > y.year() ? false
1546 : (x.month() < y.month()));
1547}
1548
1549CONSTCD11
1550inline
1551bool
1552operator>(const year_month& x, const year_month& y) NOEXCEPT
1553{
1554 return y < x;
1555}
1556
1557CONSTCD11
1558inline
1559bool
1560operator<=(const year_month& x, const year_month& y) NOEXCEPT
1561{
1562 return !(y < x);
1563}
1564
1565CONSTCD11
1566inline
1567bool
1568operator>=(const year_month& x, const year_month& y) NOEXCEPT
1569{
1570 return !(x < y);
1571}
1572
1573CONSTCD14
1574inline
1575year_month
1576operator+(const year_month& ym, const months& dm) NOEXCEPT
1577{
1578 auto dmi = static_cast<int>(static_cast<unsigned>(ym.month())) - 1 + dm.count();
1579 auto dy = (dmi >= 0 ? dmi : dmi-11) / 12;
1580 dmi = dmi - dy * 12 + 1;
1581 return (ym.year() + years(dy)) / month(static_cast<unsigned>(dmi));
1582}
1583
1584CONSTCD14
1585inline
1586year_month
1587operator+(const months& dm, const year_month& ym) NOEXCEPT
1588{
1589 return ym + dm;
1590}
1591
1592CONSTCD14
1593inline
1594year_month
1595operator-(const year_month& ym, const months& dm) NOEXCEPT
1596{
1597 return ym + -dm;
1598}
1599
1600CONSTCD11
1601inline
1602months
1603operator-(const year_month& x, const year_month& y) NOEXCEPT
1604{
1605 return (x.year() - y.year()) +
1606 months(static_cast<unsigned>(x.month()) - static_cast<unsigned>(y.month()));
1607}
1608
1609CONSTCD11
1610inline
1611year_month
1612operator+(const year_month& ym, const years& dy) NOEXCEPT
1613{
1614 return (ym.year() + dy) / ym.month();
1615}
1616
1617CONSTCD11
1618inline
1619year_month
1620operator+(const years& dy, const year_month& ym) NOEXCEPT
1621{
1622 return ym + dy;
1623}
1624
1625CONSTCD11
1626inline
1627year_month
1628operator-(const year_month& ym, const years& dy) NOEXCEPT
1629{
1630 return ym + -dy;
1631}
1632
1633template<class CharT, class Traits>
1634inline
1635std::basic_ostream<CharT, Traits>&
1636operator<<(std::basic_ostream<CharT, Traits>& os, const year_month& ym)
1637{
1638 return os << ym.year() << '/' << ym.month();
1639}
1640
1641// month_day
1642
1643CONSTCD11
1644inline
1645month_day::month_day(const julian::month& m, const julian::day& d) NOEXCEPT
1646 : m_(m)
1647 , d_(d)
1648 {}
1649
1650CONSTCD11 inline julian::month month_day::month() const NOEXCEPT {return m_;}
1651CONSTCD11 inline julian::day month_day::day() const NOEXCEPT {return d_;}
1652
1653CONSTCD14
1654inline
1655bool
1656month_day::ok() const NOEXCEPT
1657{
1658 CONSTDATA julian::day d[] = {
1659 julian::day(31), julian::day(29), julian::day(31), julian::day(30),
1660 julian::day(31), julian::day(30), julian::day(31), julian::day(31),
1661 julian::day(30), julian::day(31), julian::day(30), julian::day(31)
1662 };
1663 return m_.ok() && julian::day(1) <= d_ && d_ <= d[static_cast<unsigned>(m_)-1];
1664}
1665
1666CONSTCD11
1667inline
1668bool
1669operator==(const month_day& x, const month_day& y) NOEXCEPT
1670{
1671 return x.month() == y.month() && x.day() == y.day();
1672}
1673
1674CONSTCD11
1675inline
1676bool
1677operator!=(const month_day& x, const month_day& y) NOEXCEPT
1678{
1679 return !(x == y);
1680}
1681
1682CONSTCD11
1683inline
1684bool
1685operator<(const month_day& x, const month_day& y) NOEXCEPT
1686{
1687 return x.month() < y.month() ? true
1688 : (x.month() > y.month() ? false
1689 : (x.day() < y.day()));
1690}
1691
1692CONSTCD11
1693inline
1694bool
1695operator>(const month_day& x, const month_day& y) NOEXCEPT
1696{
1697 return y < x;
1698}
1699
1700CONSTCD11
1701inline
1702bool
1703operator<=(const month_day& x, const month_day& y) NOEXCEPT
1704{
1705 return !(y < x);
1706}
1707
1708CONSTCD11
1709inline
1710bool
1711operator>=(const month_day& x, const month_day& y) NOEXCEPT
1712{
1713 return !(x < y);
1714}
1715
1716template<class CharT, class Traits>
1717inline
1718std::basic_ostream<CharT, Traits>&
1719operator<<(std::basic_ostream<CharT, Traits>& os, const month_day& md)
1720{
1721 return os << md.month() << '/' << md.day();
1722}
1723
1724// month_day_last
1725
1726CONSTCD11 inline month month_day_last::month() const NOEXCEPT {return m_;}
1727CONSTCD11 inline bool month_day_last::ok() const NOEXCEPT {return m_.ok();}
1728CONSTCD11 inline month_day_last::month_day_last(const julian::month& m) NOEXCEPT : m_(m) {}
1729
1730CONSTCD11
1731inline
1732bool
1733operator==(const month_day_last& x, const month_day_last& y) NOEXCEPT
1734{
1735 return x.month() == y.month();
1736}
1737
1738CONSTCD11
1739inline
1740bool
1741operator!=(const month_day_last& x, const month_day_last& y) NOEXCEPT
1742{
1743 return !(x == y);
1744}
1745
1746CONSTCD11
1747inline
1748bool
1749operator<(const month_day_last& x, const month_day_last& y) NOEXCEPT
1750{
1751 return x.month() < y.month();
1752}
1753
1754CONSTCD11
1755inline
1756bool
1757operator>(const month_day_last& x, const month_day_last& y) NOEXCEPT
1758{
1759 return y < x;
1760}
1761
1762CONSTCD11
1763inline
1764bool
1765operator<=(const month_day_last& x, const month_day_last& y) NOEXCEPT
1766{
1767 return !(y < x);
1768}
1769
1770CONSTCD11
1771inline
1772bool
1773operator>=(const month_day_last& x, const month_day_last& y) NOEXCEPT
1774{
1775 return !(x < y);
1776}
1777
1778template<class CharT, class Traits>
1779inline
1780std::basic_ostream<CharT, Traits>&
1781operator<<(std::basic_ostream<CharT, Traits>& os, const month_day_last& mdl)
1782{
1783 return os << mdl.month() << "/last";
1784}
1785
1786// month_weekday
1787
1788CONSTCD11
1789inline
1790month_weekday::month_weekday(const julian::month& m,
1791 const julian::weekday_indexed& wdi) NOEXCEPT
1792 : m_(m)
1793 , wdi_(wdi)
1794 {}
1795
1796CONSTCD11 inline month month_weekday::month() const NOEXCEPT {return m_;}
1797
1798CONSTCD11
1799inline
1800weekday_indexed
1801month_weekday::weekday_indexed() const NOEXCEPT
1802{
1803 return wdi_;
1804}
1805
1806CONSTCD11
1807inline
1808bool
1809month_weekday::ok() const NOEXCEPT
1810{
1811 return m_.ok() && wdi_.ok();
1812}
1813
1814CONSTCD11
1815inline
1816bool
1817operator==(const month_weekday& x, const month_weekday& y) NOEXCEPT
1818{
1819 return x.month() == y.month() && x.weekday_indexed() == y.weekday_indexed();
1820}
1821
1822CONSTCD11
1823inline
1824bool
1825operator!=(const month_weekday& x, const month_weekday& y) NOEXCEPT
1826{
1827 return !(x == y);
1828}
1829
1830template<class CharT, class Traits>
1831inline
1832std::basic_ostream<CharT, Traits>&
1833operator<<(std::basic_ostream<CharT, Traits>& os, const month_weekday& mwd)
1834{
1835 return os << mwd.month() << '/' << mwd.weekday_indexed();
1836}
1837
1838// month_weekday_last
1839
1840CONSTCD11
1841inline
1842month_weekday_last::month_weekday_last(const julian::month& m,
1843 const julian::weekday_last& wdl) NOEXCEPT
1844 : m_(m)
1845 , wdl_(wdl)
1846 {}
1847
1848CONSTCD11 inline month month_weekday_last::month() const NOEXCEPT {return m_;}
1849
1850CONSTCD11
1851inline
1852weekday_last
1853month_weekday_last::weekday_last() const NOEXCEPT
1854{
1855 return wdl_;
1856}
1857
1858CONSTCD11
1859inline
1860bool
1861month_weekday_last::ok() const NOEXCEPT
1862{
1863 return m_.ok() && wdl_.ok();
1864}
1865
1866CONSTCD11
1867inline
1868bool
1869operator==(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT
1870{
1871 return x.month() == y.month() && x.weekday_last() == y.weekday_last();
1872}
1873
1874CONSTCD11
1875inline
1876bool
1877operator!=(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT
1878{
1879 return !(x == y);
1880}
1881
1882template<class CharT, class Traits>
1883inline
1884std::basic_ostream<CharT, Traits>&
1885operator<<(std::basic_ostream<CharT, Traits>& os, const month_weekday_last& mwdl)
1886{
1887 return os << mwdl.month() << '/' << mwdl.weekday_last();
1888}
1889
1890// year_month_day_last
1891
1892CONSTCD11
1893inline
1894year_month_day_last::year_month_day_last(const julian::year& y,
1895 const julian::month_day_last& mdl) NOEXCEPT
1896 : y_(y)
1897 , mdl_(mdl)
1898 {}
1899
1900CONSTCD14
1901inline
1902year_month_day_last&
1903year_month_day_last::operator+=(const months& m) NOEXCEPT
1904{
1905 *this = *this + m;
1906 return *this;
1907}
1908
1909CONSTCD14
1910inline
1911year_month_day_last&
1912year_month_day_last::operator-=(const months& m) NOEXCEPT
1913{
1914 *this = *this - m;
1915 return *this;
1916}
1917
1918CONSTCD14
1919inline
1920year_month_day_last&
1921year_month_day_last::operator+=(const years& y) NOEXCEPT
1922{
1923 *this = *this + y;
1924 return *this;
1925}
1926
1927CONSTCD14
1928inline
1929year_month_day_last&
1930year_month_day_last::operator-=(const years& y) NOEXCEPT
1931{
1932 *this = *this - y;
1933 return *this;
1934}
1935
1936CONSTCD11 inline year year_month_day_last::year() const NOEXCEPT {return y_;}
1937CONSTCD11 inline month year_month_day_last::month() const NOEXCEPT {return mdl_.month();}
1938
1939CONSTCD11
1940inline
1941month_day_last
1942year_month_day_last::month_day_last() const NOEXCEPT
1943{
1944 return mdl_;
1945}
1946
1947CONSTCD14
1948inline
1949day
1950year_month_day_last::day() const NOEXCEPT
1951{
1952 CONSTDATA julian::day d[] = {
1953 julian::day(31), julian::day(28), julian::day(31), julian::day(30),
1954 julian::day(31), julian::day(30), julian::day(31), julian::day(31),
1955 julian::day(30), julian::day(31), julian::day(30), julian::day(31)
1956 };
1957 return month() != feb || !y_.is_leap() ? d[static_cast<unsigned>(month())-1] : julian::day(29);
1958}
1959
1960CONSTCD14
1961inline
1962year_month_day_last::operator sys_days() const NOEXCEPT
1963{
1964 return sys_days(year()/month()/day());
1965}
1966
1967CONSTCD14
1968inline
1969year_month_day_last::operator local_days() const NOEXCEPT
1970{
1971 return local_days(year()/month()/day());
1972}
1973
1974CONSTCD11
1975inline
1976bool
1977year_month_day_last::ok() const NOEXCEPT
1978{
1979 return y_.ok() && mdl_.ok();
1980}
1981
1982CONSTCD11
1983inline
1984bool
1985operator==(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
1986{
1987 return x.year() == y.year() && x.month_day_last() == y.month_day_last();
1988}
1989
1990CONSTCD11
1991inline
1992bool
1993operator!=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
1994{
1995 return !(x == y);
1996}
1997
1998CONSTCD11
1999inline
2000bool
2001operator<(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
2002{
2003 return x.year() < y.year() ? true
2004 : (x.year() > y.year() ? false
2005 : (x.month_day_last() < y.month_day_last()));
2006}
2007
2008CONSTCD11
2009inline
2010bool
2011operator>(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
2012{
2013 return y < x;
2014}
2015
2016CONSTCD11
2017inline
2018bool
2019operator<=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
2020{
2021 return !(y < x);
2022}
2023
2024CONSTCD11
2025inline
2026bool
2027operator>=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT
2028{
2029 return !(x < y);
2030}
2031
2032template<class CharT, class Traits>
2033inline
2034std::basic_ostream<CharT, Traits>&
2035operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day_last& ymdl)
2036{
2037 return os << ymdl.year() << '/' << ymdl.month_day_last();
2038}
2039
2040CONSTCD14
2041inline
2042year_month_day_last
2043operator+(const year_month_day_last& ymdl, const months& dm) NOEXCEPT
2044{
2045 return (ymdl.year() / ymdl.month() + dm) / last;
2046}
2047
2048CONSTCD14
2049inline
2050year_month_day_last
2051operator+(const months& dm, const year_month_day_last& ymdl) NOEXCEPT
2052{
2053 return ymdl + dm;
2054}
2055
2056CONSTCD14
2057inline
2058year_month_day_last
2059operator-(const year_month_day_last& ymdl, const months& dm) NOEXCEPT
2060{
2061 return ymdl + (-dm);
2062}
2063
2064CONSTCD11
2065inline
2066year_month_day_last
2067operator+(const year_month_day_last& ymdl, const years& dy) NOEXCEPT
2068{
2069 return {ymdl.year()+dy, ymdl.month_day_last()};
2070}
2071
2072CONSTCD11
2073inline
2074year_month_day_last
2075operator+(const years& dy, const year_month_day_last& ymdl) NOEXCEPT
2076{
2077 return ymdl + dy;
2078}
2079
2080CONSTCD11
2081inline
2082year_month_day_last
2083operator-(const year_month_day_last& ymdl, const years& dy) NOEXCEPT
2084{
2085 return ymdl + (-dy);
2086}
2087
2088// year_month_day
2089
2090CONSTCD11
2091inline
2092year_month_day::year_month_day(const julian::year& y, const julian::month& m,
2093 const julian::day& d) NOEXCEPT
2094 : y_(y)
2095 , m_(m)
2096 , d_(d)
2097 {}
2098
2099CONSTCD14
2100inline
2101year_month_day::year_month_day(const year_month_day_last& ymdl) NOEXCEPT
2102 : y_(ymdl.year())
2103 , m_(ymdl.month())
2104 , d_(ymdl.day())
2105 {}
2106
2107CONSTCD14
2108inline
2109year_month_day::year_month_day(sys_days dp) NOEXCEPT
2110 : year_month_day(from_days(dp.time_since_epoch()))
2111 {}
2112
2113CONSTCD14
2114inline
2115year_month_day::year_month_day(local_days dp) NOEXCEPT
2116 : year_month_day(from_days(dp.time_since_epoch()))
2117 {}
2118
2119CONSTCD11 inline year year_month_day::year() const NOEXCEPT {return y_;}
2120CONSTCD11 inline month year_month_day::month() const NOEXCEPT {return m_;}
2121CONSTCD11 inline day year_month_day::day() const NOEXCEPT {return d_;}
2122
2123CONSTCD14
2124inline
2125year_month_day&
2126year_month_day::operator+=(const months& m) NOEXCEPT
2127{
2128 *this = *this + m;
2129 return *this;
2130}
2131
2132CONSTCD14
2133inline
2134year_month_day&
2135year_month_day::operator-=(const months& m) NOEXCEPT
2136{
2137 *this = *this - m;
2138 return *this;
2139}
2140
2141CONSTCD14
2142inline
2143year_month_day&
2144year_month_day::operator+=(const years& y) NOEXCEPT
2145{
2146 *this = *this + y;
2147 return *this;
2148}
2149
2150CONSTCD14
2151inline
2152year_month_day&
2153year_month_day::operator-=(const years& y) NOEXCEPT
2154{
2155 *this = *this - y;
2156 return *this;
2157}
2158
2159CONSTCD14
2160inline
2161days
2162year_month_day::to_days() const NOEXCEPT
2163{
2164 static_assert(std::numeric_limits<unsigned>::digits >= 18,
2165 "This algorithm has not been ported to a 16 bit unsigned integer");
2166 static_assert(std::numeric_limits<int>::digits >= 20,
2167 "This algorithm has not been ported to a 16 bit signed integer");
2168 auto const y = static_cast<int>(y_) - (m_ <= feb);
2169 auto const m = static_cast<unsigned>(m_);
2170 auto const d = static_cast<unsigned>(d_);
2171 auto const era = (y >= 0 ? y : y-3) / 4;
2172 auto const yoe = static_cast<unsigned>(y - era * 4); // [0, 3]
2173 auto const doy = (153*(m > 2 ? m-3 : m+9) + 2)/5 + d-1; // [0, 365]
2174 auto const doe = yoe * 365 + doy; // [0, 1460]
2175 return days{era * 1461 + static_cast<int>(doe) - 719470};
2176}
2177
2178CONSTCD14
2179inline
2180year_month_day::operator sys_days() const NOEXCEPT
2181{
2182 return sys_days{to_days()};
2183}
2184
2185CONSTCD14
2186inline
2187year_month_day::operator local_days() const NOEXCEPT
2188{
2189 return local_days{to_days()};
2190}
2191
2192CONSTCD14
2193inline
2194bool
2195year_month_day::ok() const NOEXCEPT
2196{
2197 if (!(y_.ok() && m_.ok()))
2198 return false;
2199 return julian::day(1) <= d_ && d_ <= (y_/m_/last).day();
2200}
2201
2202CONSTCD11
2203inline
2204bool
2205operator==(const year_month_day& x, const year_month_day& y) NOEXCEPT
2206{
2207 return x.year() == y.year() && x.month() == y.month() && x.day() == y.day();
2208}
2209
2210CONSTCD11
2211inline
2212bool
2213operator!=(const year_month_day& x, const year_month_day& y) NOEXCEPT
2214{
2215 return !(x == y);
2216}
2217
2218CONSTCD11
2219inline
2220bool
2221operator<(const year_month_day& x, const year_month_day& y) NOEXCEPT
2222{
2223 return x.year() < y.year() ? true
2224 : (x.year() > y.year() ? false
2225 : (x.month() < y.month() ? true
2226 : (x.month() > y.month() ? false
2227 : (x.day() < y.day()))));
2228}
2229
2230CONSTCD11
2231inline
2232bool
2233operator>(const year_month_day& x, const year_month_day& y) NOEXCEPT
2234{
2235 return y < x;
2236}
2237
2238CONSTCD11
2239inline
2240bool
2241operator<=(const year_month_day& x, const year_month_day& y) NOEXCEPT
2242{
2243 return !(y < x);
2244}
2245
2246CONSTCD11
2247inline
2248bool
2249operator>=(const year_month_day& x, const year_month_day& y) NOEXCEPT
2250{
2251 return !(x < y);
2252}
2253
2254template<class CharT, class Traits>
2255inline
2256std::basic_ostream<CharT, Traits>&
2257operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_day& ymd)
2258{
2259 date::detail::save_ostream<CharT, Traits> _(os);
2260 os.fill('0');
2261 os.flags(std::ios::dec | std::ios::right);
2262 os << ymd.year() << '-';
2263 os.width(2);
2264 os << static_cast<unsigned>(ymd.month()) << '-';
2265 os << ymd.day();
2266 return os;
2267}
2268
2269CONSTCD14
2270inline
2271year_month_day
2272year_month_day::from_days(days dp) NOEXCEPT
2273{
2274 static_assert(std::numeric_limits<unsigned>::digits >= 18,
2275 "This algorithm has not been ported to a 16 bit unsigned integer");
2276 static_assert(std::numeric_limits<int>::digits >= 20,
2277 "This algorithm has not been ported to a 16 bit signed integer");
2278 auto const z = dp.count() + 719470;
2279 auto const era = (z >= 0 ? z : z - 1460) / 1461;
2280 auto const doe = static_cast<unsigned>(z - era * 1461); // [0, 1460]
2281 auto const yoe = (doe - doe/1460) / 365; // [0, 3]
2282 auto const y = static_cast<sys_days::rep>(yoe) + era * 4;
2283 auto const doy = doe - 365*yoe; // [0, 365]
2284 auto const mp = (5*doy + 2)/153; // [0, 11]
2285 auto const d = doy - (153*mp+2)/5 + 1; // [1, 31]
2286 auto const m = mp < 10 ? mp+3 : mp-9; // [1, 12]
2287 return year_month_day{julian::year{y + (m <= 2)}, julian::month(m), julian::day(d)};
2288}
2289
2290CONSTCD14
2291inline
2292year_month_day
2293operator+(const year_month_day& ymd, const months& dm) NOEXCEPT
2294{
2295 return (ymd.year() / ymd.month() + dm) / ymd.day();
2296}
2297
2298CONSTCD14
2299inline
2300year_month_day
2301operator+(const months& dm, const year_month_day& ymd) NOEXCEPT
2302{
2303 return ymd + dm;
2304}
2305
2306CONSTCD14
2307inline
2308year_month_day
2309operator-(const year_month_day& ymd, const months& dm) NOEXCEPT
2310{
2311 return ymd + (-dm);
2312}
2313
2314CONSTCD11
2315inline
2316year_month_day
2317operator+(const year_month_day& ymd, const years& dy) NOEXCEPT
2318{
2319 return (ymd.year() + dy) / ymd.month() / ymd.day();
2320}
2321
2322CONSTCD11
2323inline
2324year_month_day
2325operator+(const years& dy, const year_month_day& ymd) NOEXCEPT
2326{
2327 return ymd + dy;
2328}
2329
2330CONSTCD11
2331inline
2332year_month_day
2333operator-(const year_month_day& ymd, const years& dy) NOEXCEPT
2334{
2335 return ymd + (-dy);
2336}
2337
2338// year_month_weekday
2339
2340CONSTCD11
2341inline
2342year_month_weekday::year_month_weekday(const julian::year& y, const julian::month& m,
2343 const julian::weekday_indexed& wdi)
2344 NOEXCEPT
2345 : y_(y)
2346 , m_(m)
2347 , wdi_(wdi)
2348 {}
2349
2350CONSTCD14
2351inline
2352year_month_weekday::year_month_weekday(const sys_days& dp) NOEXCEPT
2353 : year_month_weekday(from_days(dp.time_since_epoch()))
2354 {}
2355
2356CONSTCD14
2357inline
2358year_month_weekday::year_month_weekday(const local_days& dp) NOEXCEPT
2359 : year_month_weekday(from_days(dp.time_since_epoch()))
2360 {}
2361
2362CONSTCD14
2363inline
2364year_month_weekday&
2365year_month_weekday::operator+=(const months& m) NOEXCEPT
2366{
2367 *this = *this + m;
2368 return *this;
2369}
2370
2371CONSTCD14
2372inline
2373year_month_weekday&
2374year_month_weekday::operator-=(const months& m) NOEXCEPT
2375{
2376 *this = *this - m;
2377 return *this;
2378}
2379
2380CONSTCD14
2381inline
2382year_month_weekday&
2383year_month_weekday::operator+=(const years& y) NOEXCEPT
2384{
2385 *this = *this + y;
2386 return *this;
2387}
2388
2389CONSTCD14
2390inline
2391year_month_weekday&
2392year_month_weekday::operator-=(const years& y) NOEXCEPT
2393{
2394 *this = *this - y;
2395 return *this;
2396}
2397
2398CONSTCD11 inline year year_month_weekday::year() const NOEXCEPT {return y_;}
2399CONSTCD11 inline month year_month_weekday::month() const NOEXCEPT {return m_;}
2400
2401CONSTCD11
2402inline
2403weekday
2404year_month_weekday::weekday() const NOEXCEPT
2405{
2406 return wdi_.weekday();
2407}
2408
2409CONSTCD11
2410inline
2411unsigned
2412year_month_weekday::index() const NOEXCEPT
2413{
2414 return wdi_.index();
2415}
2416
2417CONSTCD11
2418inline
2419weekday_indexed
2420year_month_weekday::weekday_indexed() const NOEXCEPT
2421{
2422 return wdi_;
2423}
2424
2425CONSTCD14
2426inline
2427year_month_weekday::operator sys_days() const NOEXCEPT
2428{
2429 return sys_days{to_days()};
2430}
2431
2432CONSTCD14
2433inline
2434year_month_weekday::operator local_days() const NOEXCEPT
2435{
2436 return local_days{to_days()};
2437}
2438
2439CONSTCD14
2440inline
2441bool
2442year_month_weekday::ok() const NOEXCEPT
2443{
2444 if (!y_.ok() || !m_.ok() || !wdi_.weekday().ok() || wdi_.index() < 1)
2445 return false;
2446 if (wdi_.index() <= 4)
2447 return true;
2448 auto d2 = wdi_.weekday() - julian::weekday(y_/m_/1) + days((wdi_.index()-1)*7 + 1);
2449 return static_cast<unsigned>(d2.count()) <= static_cast<unsigned>((y_/m_/last).day());
2450}
2451
2452CONSTCD14
2453inline
2454year_month_weekday
2455year_month_weekday::from_days(days d) NOEXCEPT
2456{
2457 sys_days dp{d};
2458 auto const wd = julian::weekday(dp);
2459 auto const ymd = year_month_day(dp);
2460 return {ymd.year(), ymd.month(), wd[(static_cast<unsigned>(ymd.day())-1)/7+1]};
2461}
2462
2463CONSTCD14
2464inline
2465days
2466year_month_weekday::to_days() const NOEXCEPT
2467{
2468 auto d = sys_days(y_/m_/1);
2469 return (d + (wdi_.weekday() - julian::weekday(d) + days{(wdi_.index()-1)*7})
2470 ).time_since_epoch();
2471}
2472
2473CONSTCD11
2474inline
2475bool
2476operator==(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT
2477{
2478 return x.year() == y.year() && x.month() == y.month() &&
2479 x.weekday_indexed() == y.weekday_indexed();
2480}
2481
2482CONSTCD11
2483inline
2484bool
2485operator!=(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT
2486{
2487 return !(x == y);
2488}
2489
2490template<class CharT, class Traits>
2491inline
2492std::basic_ostream<CharT, Traits>&
2493operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday& ymwdi)
2494{
2495 return os << ymwdi.year() << '/' << ymwdi.month()
2496 << '/' << ymwdi.weekday_indexed();
2497}
2498
2499CONSTCD14
2500inline
2501year_month_weekday
2502operator+(const year_month_weekday& ymwd, const months& dm) NOEXCEPT
2503{
2504 return (ymwd.year() / ymwd.month() + dm) / ymwd.weekday_indexed();
2505}
2506
2507CONSTCD14
2508inline
2509year_month_weekday
2510operator+(const months& dm, const year_month_weekday& ymwd) NOEXCEPT
2511{
2512 return ymwd + dm;
2513}
2514
2515CONSTCD14
2516inline
2517year_month_weekday
2518operator-(const year_month_weekday& ymwd, const months& dm) NOEXCEPT
2519{
2520 return ymwd + (-dm);
2521}
2522
2523CONSTCD11
2524inline
2525year_month_weekday
2526operator+(const year_month_weekday& ymwd, const years& dy) NOEXCEPT
2527{
2528 return {ymwd.year()+dy, ymwd.month(), ymwd.weekday_indexed()};
2529}
2530
2531CONSTCD11
2532inline
2533year_month_weekday
2534operator+(const years& dy, const year_month_weekday& ymwd) NOEXCEPT
2535{
2536 return ymwd + dy;
2537}
2538
2539CONSTCD11
2540inline
2541year_month_weekday
2542operator-(const year_month_weekday& ymwd, const years& dy) NOEXCEPT
2543{
2544 return ymwd + (-dy);
2545}
2546
2547// year_month_weekday_last
2548
2549CONSTCD11
2550inline
2551year_month_weekday_last::year_month_weekday_last(const julian::year& y,
2552 const julian::month& m,
2553 const julian::weekday_last& wdl) NOEXCEPT
2554 : y_(y)
2555 , m_(m)
2556 , wdl_(wdl)
2557 {}
2558
2559CONSTCD14
2560inline
2561year_month_weekday_last&
2562year_month_weekday_last::operator+=(const months& m) NOEXCEPT
2563{
2564 *this = *this + m;
2565 return *this;
2566}
2567
2568CONSTCD14
2569inline
2570year_month_weekday_last&
2571year_month_weekday_last::operator-=(const months& m) NOEXCEPT
2572{
2573 *this = *this - m;
2574 return *this;
2575}
2576
2577CONSTCD14
2578inline
2579year_month_weekday_last&
2580year_month_weekday_last::operator+=(const years& y) NOEXCEPT
2581{
2582 *this = *this + y;
2583 return *this;
2584}
2585
2586CONSTCD14
2587inline
2588year_month_weekday_last&
2589year_month_weekday_last::operator-=(const years& y) NOEXCEPT
2590{
2591 *this = *this - y;
2592 return *this;
2593}
2594
2595CONSTCD11 inline year year_month_weekday_last::year() const NOEXCEPT {return y_;}
2596CONSTCD11 inline month year_month_weekday_last::month() const NOEXCEPT {return m_;}
2597
2598CONSTCD11
2599inline
2600weekday
2601year_month_weekday_last::weekday() const NOEXCEPT
2602{
2603 return wdl_.weekday();
2604}
2605
2606CONSTCD11
2607inline
2608weekday_last
2609year_month_weekday_last::weekday_last() const NOEXCEPT
2610{
2611 return wdl_;
2612}
2613
2614CONSTCD14
2615inline
2616year_month_weekday_last::operator sys_days() const NOEXCEPT
2617{
2618 return sys_days{to_days()};
2619}
2620
2621CONSTCD14
2622inline
2623year_month_weekday_last::operator local_days() const NOEXCEPT
2624{
2625 return local_days{to_days()};
2626}
2627
2628CONSTCD11
2629inline
2630bool
2631year_month_weekday_last::ok() const NOEXCEPT
2632{
2633 return y_.ok() && m_.ok() && wdl_.ok();
2634}
2635
2636CONSTCD14
2637inline
2638days
2639year_month_weekday_last::to_days() const NOEXCEPT
2640{
2641 auto const d = sys_days(y_/m_/last);
2642 return (d - (julian::weekday{d} - wdl_.weekday())).time_since_epoch();
2643}
2644
2645CONSTCD11
2646inline
2647bool
2648operator==(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT
2649{
2650 return x.year() == y.year() && x.month() == y.month() &&
2651 x.weekday_last() == y.weekday_last();
2652}
2653
2654CONSTCD11
2655inline
2656bool
2657operator!=(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT
2658{
2659 return !(x == y);
2660}
2661
2662template<class CharT, class Traits>
2663inline
2664std::basic_ostream<CharT, Traits>&
2665operator<<(std::basic_ostream<CharT, Traits>& os, const year_month_weekday_last& ymwdl)
2666{
2667 return os << ymwdl.year() << '/' << ymwdl.month() << '/' << ymwdl.weekday_last();
2668}
2669
2670CONSTCD14
2671inline
2672year_month_weekday_last
2673operator+(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT
2674{
2675 return (ymwdl.year() / ymwdl.month() + dm) / ymwdl.weekday_last();
2676}
2677
2678CONSTCD14
2679inline
2680year_month_weekday_last
2681operator+(const months& dm, const year_month_weekday_last& ymwdl) NOEXCEPT
2682{
2683 return ymwdl + dm;
2684}
2685
2686CONSTCD14
2687inline
2688year_month_weekday_last
2689operator-(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT
2690{
2691 return ymwdl + (-dm);
2692}
2693
2694CONSTCD11
2695inline
2696year_month_weekday_last
2697operator+(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT
2698{
2699 return {ymwdl.year()+dy, ymwdl.month(), ymwdl.weekday_last()};
2700}
2701
2702CONSTCD11
2703inline
2704year_month_weekday_last
2705operator+(const years& dy, const year_month_weekday_last& ymwdl) NOEXCEPT
2706{
2707 return ymwdl + dy;
2708}
2709
2710CONSTCD11
2711inline
2712year_month_weekday_last
2713operator-(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT
2714{
2715 return ymwdl + (-dy);
2716}
2717
2718// year_month from operator/()
2719
2720CONSTCD11
2721inline
2722year_month
2723operator/(const year& y, const month& m) NOEXCEPT
2724{
2725 return {y, m};
2726}
2727
2728CONSTCD11
2729inline
2730year_month
2731operator/(const year& y, int m) NOEXCEPT
2732{
2733 return y / month(static_cast<unsigned>(m));
2734}
2735
2736// month_day from operator/()
2737
2738CONSTCD11
2739inline
2740month_day
2741operator/(const month& m, const day& d) NOEXCEPT
2742{
2743 return {m, d};
2744}
2745
2746CONSTCD11
2747inline
2748month_day
2749operator/(const day& d, const month& m) NOEXCEPT
2750{
2751 return m / d;
2752}
2753
2754CONSTCD11
2755inline
2756month_day
2757operator/(const month& m, int d) NOEXCEPT
2758{
2759 return m / day(static_cast<unsigned>(d));
2760}
2761
2762CONSTCD11
2763inline
2764month_day
2765operator/(int m, const day& d) NOEXCEPT
2766{
2767 return month(static_cast<unsigned>(m)) / d;
2768}
2769
2770CONSTCD11 inline month_day operator/(const day& d, int m) NOEXCEPT {return m / d;}
2771
2772// month_day_last from operator/()
2773
2774CONSTCD11
2775inline
2776month_day_last
2777operator/(const month& m, last_spec) NOEXCEPT
2778{
2779 return month_day_last{m};
2780}
2781
2782CONSTCD11
2783inline
2784month_day_last
2785operator/(last_spec, const month& m) NOEXCEPT
2786{
2787 return m/last;
2788}
2789
2790CONSTCD11
2791inline
2792month_day_last
2793operator/(int m, last_spec) NOEXCEPT
2794{
2795 return month(static_cast<unsigned>(m))/last;
2796}
2797
2798CONSTCD11
2799inline
2800month_day_last
2801operator/(last_spec, int m) NOEXCEPT
2802{
2803 return m/last;
2804}
2805
2806// month_weekday from operator/()
2807
2808CONSTCD11
2809inline
2810month_weekday
2811operator/(const month& m, const weekday_indexed& wdi) NOEXCEPT
2812{
2813 return {m, wdi};
2814}
2815
2816CONSTCD11
2817inline
2818month_weekday
2819operator/(const weekday_indexed& wdi, const month& m) NOEXCEPT
2820{
2821 return m / wdi;
2822}
2823
2824CONSTCD11
2825inline
2826month_weekday
2827operator/(int m, const weekday_indexed& wdi) NOEXCEPT
2828{
2829 return month(static_cast<unsigned>(m)) / wdi;
2830}
2831
2832CONSTCD11
2833inline
2834month_weekday
2835operator/(const weekday_indexed& wdi, int m) NOEXCEPT
2836{
2837 return m / wdi;
2838}
2839
2840// month_weekday_last from operator/()
2841
2842CONSTCD11
2843inline
2844month_weekday_last
2845operator/(const month& m, const weekday_last& wdl) NOEXCEPT
2846{
2847 return {m, wdl};
2848}
2849
2850CONSTCD11
2851inline
2852month_weekday_last
2853operator/(const weekday_last& wdl, const month& m) NOEXCEPT
2854{
2855 return m / wdl;
2856}
2857
2858CONSTCD11
2859inline
2860month_weekday_last
2861operator/(int m, const weekday_last& wdl) NOEXCEPT
2862{
2863 return month(static_cast<unsigned>(m)) / wdl;
2864}
2865
2866CONSTCD11
2867inline
2868month_weekday_last
2869operator/(const weekday_last& wdl, int m) NOEXCEPT
2870{
2871 return m / wdl;
2872}
2873
2874// year_month_day from operator/()
2875
2876CONSTCD11
2877inline
2878year_month_day
2879operator/(const year_month& ym, const day& d) NOEXCEPT
2880{
2881 return {ym.year(), ym.month(), d};
2882}
2883
2884CONSTCD11
2885inline
2886year_month_day
2887operator/(const year_month& ym, int d) NOEXCEPT
2888{
2889 return ym / day(static_cast<unsigned>(d));
2890}
2891
2892CONSTCD11
2893inline
2894year_month_day
2895operator/(const year& y, const month_day& md) NOEXCEPT
2896{
2897 return y / md.month() / md.day();
2898}
2899
2900CONSTCD11
2901inline
2902year_month_day
2903operator/(int y, const month_day& md) NOEXCEPT
2904{
2905 return year(y) / md;
2906}
2907
2908CONSTCD11
2909inline
2910year_month_day
2911operator/(const month_day& md, const year& y) NOEXCEPT
2912{
2913 return y / md;
2914}
2915
2916CONSTCD11
2917inline
2918year_month_day
2919operator/(const month_day& md, int y) NOEXCEPT
2920{
2921 return year(y) / md;
2922}
2923
2924// year_month_day_last from operator/()
2925
2926CONSTCD11
2927inline
2928year_month_day_last
2929operator/(const year_month& ym, last_spec) NOEXCEPT
2930{
2931 return {ym.year(), month_day_last{ym.month()}};
2932}
2933
2934CONSTCD11
2935inline
2936year_month_day_last
2937operator/(const year& y, const month_day_last& mdl) NOEXCEPT
2938{
2939 return {y, mdl};
2940}
2941
2942CONSTCD11
2943inline
2944year_month_day_last
2945operator/(int y, const month_day_last& mdl) NOEXCEPT
2946{
2947 return year(y) / mdl;
2948}
2949
2950CONSTCD11
2951inline
2952year_month_day_last
2953operator/(const month_day_last& mdl, const year& y) NOEXCEPT
2954{
2955 return y / mdl;
2956}
2957
2958CONSTCD11
2959inline
2960year_month_day_last
2961operator/(const month_day_last& mdl, int y) NOEXCEPT
2962{
2963 return year(y) / mdl;
2964}
2965
2966// year_month_weekday from operator/()
2967
2968CONSTCD11
2969inline
2970year_month_weekday
2971operator/(const year_month& ym, const weekday_indexed& wdi) NOEXCEPT
2972{
2973 return {ym.year(), ym.month(), wdi};
2974}
2975
2976CONSTCD11
2977inline
2978year_month_weekday
2979operator/(const year& y, const month_weekday& mwd) NOEXCEPT
2980{
2981 return {y, mwd.month(), mwd.weekday_indexed()};
2982}
2983
2984CONSTCD11
2985inline
2986year_month_weekday
2987operator/(int y, const month_weekday& mwd) NOEXCEPT
2988{
2989 return year(y) / mwd;
2990}
2991
2992CONSTCD11
2993inline
2994year_month_weekday
2995operator/(const month_weekday& mwd, const year& y) NOEXCEPT
2996{
2997 return y / mwd;
2998}
2999
3000CONSTCD11
3001inline
3002year_month_weekday
3003operator/(const month_weekday& mwd, int y) NOEXCEPT
3004{
3005 return year(y) / mwd;
3006}
3007
3008// year_month_weekday_last from operator/()
3009
3010CONSTCD11
3011inline
3012year_month_weekday_last
3013operator/(const year_month& ym, const weekday_last& wdl) NOEXCEPT
3014{
3015 return {ym.year(), ym.month(), wdl};
3016}
3017
3018CONSTCD11
3019inline
3020year_month_weekday_last
3021operator/(const year& y, const month_weekday_last& mwdl) NOEXCEPT
3022{
3023 return {y, mwdl.month(), mwdl.weekday_last()};
3024}
3025
3026CONSTCD11
3027inline
3028year_month_weekday_last
3029operator/(int y, const month_weekday_last& mwdl) NOEXCEPT
3030{
3031 return year(y) / mwdl;
3032}
3033
3034CONSTCD11
3035inline
3036year_month_weekday_last
3037operator/(const month_weekday_last& mwdl, const year& y) NOEXCEPT
3038{
3039 return y / mwdl;
3040}
3041
3042CONSTCD11
3043inline
3044year_month_weekday_last
3045operator/(const month_weekday_last& mwdl, int y) NOEXCEPT
3046{
3047 return year(y) / mwdl;
3048}
3049
3050} // namespace julian
3051
3052#endif // JULIAN_H
date::detail::save_ostream
Definition: date.h:1061
julian::day::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:794
julian::day::operator+=
CONSTCD14 day & operator+=(const days &d) NOEXCEPT
Definition: julian.h:791
julian::day::operator-=
CONSTCD14 day & operator-=(const days &d) NOEXCEPT
Definition: julian.h:792
julian::day::operator--
CONSTCD14 day & operator--() NOEXCEPT
Definition: julian.h:789
julian::day::operator++
CONSTCD14 day & operator++() NOEXCEPT
Definition: julian.h:787
julian::day::d_
unsigned char d_
Definition: julian.h:169
julian::day::day
CONSTCD11 day(unsigned d) NOEXCEPT
Definition: julian.h:786
julian::month_day_last
Definition: julian.h:435
julian::month_day_last::month_day_last
CONSTCD11 month_day_last(const julian::month &m) NOEXCEPT
Definition: julian.h:1728
julian::month_day_last::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:1727
julian::month_day_last::month
CONSTCD11 julian::month month() const NOEXCEPT
Definition: julian.h:1726
julian::month_day_last::m_
julian::month m_
Definition: julian.h:436
julian::month_day
Definition: julian.h:408
julian::month_day::month
CONSTCD11 julian::month month() const NOEXCEPT
Definition: julian.h:1650
julian::month_day::month_day
CONSTCD11 month_day(const julian::month &m, const julian::day &d) NOEXCEPT
Definition: julian.h:1645
julian::month_day::day
CONSTCD11 julian::day day() const NOEXCEPT
Definition: julian.h:1651
julian::month_day::ok
CONSTCD14 bool ok() const NOEXCEPT
Definition: julian.h:1656
julian::month_day::m_
julian::month m_
Definition: julian.h:409
julian::month_day::d_
julian::day d_
Definition: julian.h:410
julian::month_weekday_last
Definition: julian.h:482
julian::month_weekday_last::weekday_last
CONSTCD11 julian::weekday_last weekday_last() const NOEXCEPT
Definition: julian.h:1853
julian::month_weekday_last::m_
julian::month m_
Definition: julian.h:483
julian::month_weekday_last::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:1861
julian::month_weekday_last::wdl_
julian::weekday_last wdl_
Definition: julian.h:484
julian::month_weekday_last::month
CONSTCD11 julian::month month() const NOEXCEPT
Definition: julian.h:1848
julian::month_weekday_last::month_weekday_last
CONSTCD11 month_weekday_last(const julian::month &m, const julian::weekday_last &wd) NOEXCEPT
Definition: julian.h:1842
julian::month_weekday
Definition: julian.h:459
julian::month_weekday::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:1809
julian::month_weekday::m_
julian::month m_
Definition: julian.h:460
julian::month_weekday::wdi_
julian::weekday_indexed wdi_
Definition: julian.h:461
julian::month_weekday::month
CONSTCD11 julian::month month() const NOEXCEPT
Definition: julian.h:1796
julian::month_weekday::month_weekday
CONSTCD11 month_weekday(const julian::month &m, const julian::weekday_indexed &wdi) NOEXCEPT
Definition: julian.h:1790
julian::month_weekday::weekday_indexed
CONSTCD11 julian::weekday_indexed weekday_indexed() const NOEXCEPT
Definition: julian.h:1801
julian::month::m_
unsigned char m_
Definition: julian.h:206
julian::month::operator+=
CONSTCD14 month & operator+=(const months &m) NOEXCEPT
Definition: julian.h:901
julian::month::operator-=
CONSTCD14 month & operator-=(const months &m) NOEXCEPT
Definition: julian.h:910
julian::month::operator++
CONSTCD14 month & operator++() NOEXCEPT
Definition: julian.h:893
julian::month::month
CONSTCD11 month(unsigned m) NOEXCEPT
Definition: julian.h:892
julian::month::operator--
CONSTCD14 month & operator--() NOEXCEPT
Definition: julian.h:895
julian::month::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:917
julian::weekday_indexed
Definition: julian.h:325
julian::weekday_indexed::index
CONSTCD11 unsigned index() const NOEXCEPT
Definition: julian.h:1387
julian::weekday_indexed::weekday_indexed
CONSTCD11 weekday_indexed(const julian::weekday &wd, unsigned index) NOEXCEPT
Definition: julian.h:1399
julian::weekday_indexed::index_
unsigned char index_
Definition: julian.h:327
julian::weekday_indexed::wd_
unsigned char wd_
Definition: julian.h:326
julian::weekday_indexed::weekday
CONSTCD11 julian::weekday weekday() const NOEXCEPT
Definition: julian.h:1382
julian::weekday_indexed::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:1392
julian::weekday_last
Definition: julian.h:347
julian::weekday_last::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:1439
julian::weekday_last::wd_
julian::weekday wd_
Definition: julian.h:348
julian::weekday_last::weekday
CONSTCD11 julian::weekday weekday() const NOEXCEPT
Definition: julian.h:1438
julian::weekday_last::weekday_last
CONSTCD11 weekday_last(const julian::weekday &wd) NOEXCEPT
Definition: julian.h:1440
julian::weekday::operator++
CONSTCD14 weekday & operator++() NOEXCEPT
Definition: julian.h:1211
julian::weekday::weekday_from_days
static CONSTCD11 unsigned char weekday_from_days(int z) NOEXCEPT
Definition: julian.h:1187
julian::weekday::operator--
CONSTCD14 weekday & operator--() NOEXCEPT
Definition: julian.h:1213
julian::weekday::wd_
unsigned char wd_
Definition: julian.h:285
julian::weekday::operator-=
CONSTCD14 weekday & operator-=(const days &d) NOEXCEPT
Definition: julian.h:1228
julian::weekday::weekday
CONSTCD11 weekday(unsigned wd) NOEXCEPT
Definition: julian.h:1195
julian::weekday::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:1241
julian::weekday::weekday
weekday(int)=delete
julian::weekday::operator+=
CONSTCD14 weekday & operator+=(const days &d) NOEXCEPT
Definition: julian.h:1219
julian::weekday::operator[]
CONSTCD11 weekday_indexed operator[](unsigned index) const NOEXCEPT
Definition: julian.h:1415
julian::year_month_day_last
Definition: julian.h:560
julian::year_month_day_last::mdl_
julian::month_day_last mdl_
Definition: julian.h:562
julian::year_month_day_last::y_
julian::year y_
Definition: julian.h:561
julian::year_month_day_last::month
CONSTCD11 julian::month month() const NOEXCEPT
Definition: julian.h:1937
julian::year_month_day_last::year
CONSTCD11 julian::year year() const NOEXCEPT
Definition: julian.h:1936
julian::year_month_day_last::year_month_day_last
CONSTCD11 year_month_day_last(const julian::year &y, const julian::month_day_last &mdl) NOEXCEPT
Definition: julian.h:1894
julian::year_month_day_last::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:1977
julian::year_month_day_last::day
CONSTCD14 julian::day day() const NOEXCEPT
Definition: julian.h:1950
julian::year_month_day_last::month_day_last
CONSTCD11 julian::month_day_last month_day_last() const NOEXCEPT
Definition: julian.h:1942
julian::year_month_day_last::operator+=
CONSTCD14 year_month_day_last & operator+=(const months &m) NOEXCEPT
Definition: julian.h:1903
julian::year_month_day_last::operator-=
CONSTCD14 year_month_day_last & operator-=(const months &m) NOEXCEPT
Definition: julian.h:1912
julian::year_month_day
Definition: julian.h:508
julian::year_month_day::from_days
static CONSTCD14 year_month_day from_days(days dp) NOEXCEPT
Definition: julian.h:2272
julian::year_month_day::month
CONSTCD11 julian::month month() const NOEXCEPT
Definition: julian.h:2120
julian::year_month_day::day
CONSTCD11 julian::day day() const NOEXCEPT
Definition: julian.h:2121
julian::year_month_day::m_
julian::month m_
Definition: julian.h:510
julian::year_month_day::to_days
CONSTCD14 days to_days() const NOEXCEPT
Definition: julian.h:2162
julian::year_month_day::d_
julian::day d_
Definition: julian.h:511
julian::year_month_day::operator-=
CONSTCD14 year_month_day & operator-=(const months &m) NOEXCEPT
Definition: julian.h:2135
julian::year_month_day::year_month_day
CONSTCD11 year_month_day(const julian::year &y, const julian::month &m, const julian::day &d) NOEXCEPT
Definition: julian.h:2092
julian::year_month_day::y_
julian::year y_
Definition: julian.h:509
julian::year_month_day::year
CONSTCD11 julian::year year() const NOEXCEPT
Definition: julian.h:2119
julian::year_month_day::operator+=
CONSTCD14 year_month_day & operator+=(const months &m) NOEXCEPT
Definition: julian.h:2126
julian::year_month_day::ok
CONSTCD14 bool ok() const NOEXCEPT
Definition: julian.h:2195
julian::year_month_weekday_last
Definition: julian.h:694
julian::year_month_weekday_last::m_
julian::month m_
Definition: julian.h:696
julian::year_month_weekday_last::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:2631
julian::year_month_weekday_last::to_days
CONSTCD14 days to_days() const NOEXCEPT
Definition: julian.h:2639
julian::year_month_weekday_last::y_
julian::year y_
Definition: julian.h:695
julian::year_month_weekday_last::weekday_last
CONSTCD11 julian::weekday_last weekday_last() const NOEXCEPT
Definition: julian.h:2609
julian::year_month_weekday_last::wdl_
julian::weekday_last wdl_
Definition: julian.h:697
julian::year_month_weekday_last::operator-=
CONSTCD14 year_month_weekday_last & operator-=(const months &m) NOEXCEPT
Definition: julian.h:2571
julian::year_month_weekday_last::month
CONSTCD11 julian::month month() const NOEXCEPT
Definition: julian.h:2596
julian::year_month_weekday_last::year
CONSTCD11 julian::year year() const NOEXCEPT
Definition: julian.h:2595
julian::year_month_weekday_last::weekday
CONSTCD11 julian::weekday weekday() const NOEXCEPT
Definition: julian.h:2601
julian::year_month_weekday_last::operator+=
CONSTCD14 year_month_weekday_last & operator+=(const months &m) NOEXCEPT
Definition: julian.h:2562
julian::year_month_weekday_last::year_month_weekday_last
CONSTCD11 year_month_weekday_last(const julian::year &y, const julian::month &m, const julian::weekday_last &wdl) NOEXCEPT
Definition: julian.h:2551
julian::year_month_weekday
Definition: julian.h:627
julian::year_month_weekday::month
CONSTCD11 julian::month month() const NOEXCEPT
Definition: julian.h:2399
julian::year_month_weekday::year_month_weekday
CONSTCD11 year_month_weekday(const julian::year &y, const julian::month &m, const julian::weekday_indexed &wdi) NOEXCEPT
Definition: julian.h:2342
julian::year_month_weekday::operator-=
CONSTCD14 year_month_weekday & operator-=(const months &m) NOEXCEPT
Definition: julian.h:2374
julian::year_month_weekday::operator+=
CONSTCD14 year_month_weekday & operator+=(const months &m) NOEXCEPT
Definition: julian.h:2365
julian::year_month_weekday::weekday_indexed
CONSTCD11 julian::weekday_indexed weekday_indexed() const NOEXCEPT
Definition: julian.h:2420
julian::year_month_weekday::from_days
static CONSTCD14 year_month_weekday from_days(days dp) NOEXCEPT
Definition: julian.h:2455
julian::year_month_weekday::ok
CONSTCD14 bool ok() const NOEXCEPT
Definition: julian.h:2442
julian::year_month_weekday::year
CONSTCD11 julian::year year() const NOEXCEPT
Definition: julian.h:2398
julian::year_month_weekday::weekday
CONSTCD11 julian::weekday weekday() const NOEXCEPT
Definition: julian.h:2404
julian::year_month_weekday::y_
julian::year y_
Definition: julian.h:628
julian::year_month_weekday::to_days
CONSTCD14 days to_days() const NOEXCEPT
Definition: julian.h:2466
julian::year_month_weekday::wdi_
julian::weekday_indexed wdi_
Definition: julian.h:630
julian::year_month_weekday::m_
julian::month m_
Definition: julian.h:629
julian::year_month_weekday::index
CONSTCD11 unsigned index() const NOEXCEPT
Definition: julian.h:2412
julian::year_month
Definition: julian.h:367
julian::year_month::operator-=
CONSTCD14 year_month & operator-=(const months &dm) NOEXCEPT
Definition: julian.h:1499
julian::year_month::m_
julian::month m_
Definition: julian.h:369
julian::year_month::operator+=
CONSTCD14 year_month & operator+=(const months &dm) NOEXCEPT
Definition: julian.h:1490
julian::year_month::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:1485
julian::year_month::month
CONSTCD11 julian::month month() const NOEXCEPT
Definition: julian.h:1484
julian::year_month::y_
julian::year y_
Definition: julian.h:368
julian::year_month::year
CONSTCD11 julian::year year() const NOEXCEPT
Definition: julian.h:1483
julian::year_month::year_month
CONSTCD11 year_month(const julian::year &y, const julian::month &m) NOEXCEPT
Definition: julian.h:1478
julian::year::operator++
CONSTCD14 year & operator++() NOEXCEPT
Definition: julian.h:1055
julian::year::operator-=
CONSTCD14 year & operator-=(const years &y) NOEXCEPT
Definition: julian.h:1060
julian::year::is_leap
CONSTCD11 bool is_leap() const NOEXCEPT
Definition: julian.h:1065
julian::year::ok
CONSTCD11 bool ok() const NOEXCEPT
Definition: julian.h:1071
julian::year::operator--
CONSTCD14 year & operator--() NOEXCEPT
Definition: julian.h:1057
julian::year::max
static CONSTCD11 year max() NOEXCEPT
Definition: julian.h:1084
julian::year::operator+=
CONSTCD14 year & operator+=(const years &y) NOEXCEPT
Definition: julian.h:1059
julian::year::y_
short y_
Definition: julian.h:243
julian::year::min
static CONSTCD11 year min() NOEXCEPT
Definition: julian.h:1076
julian::year::year
CONSTCD11 year(int y) NOEXCEPT
Definition: julian.h:1054
NOEXCEPT
#define NOEXCEPT
Definition: date.h:135
CONSTDATA
#define CONSTDATA
Definition: date.h:132
CONSTCD14
#define CONSTCD14
Definition: date.h:134
CONSTCD11
#define CONSTCD11
Definition: date.h:133
date::detail::ratio_divide
decltype(std::ratio_divide< R1, R2 >{}) ratio_divide
Definition: date.h:167
date::detail::ratio_multiply
decltype(std::ratio_multiply< R1, R2 >{}) ratio_multiply
Definition: date.h:164
date::local_days
local_time< days > local_days
Definition: date.h:202
date::weeks
std::chrono::duration< int, detail::ratio_multiply< std::ratio< 7 >, days::period > > weeks
Definition: date.h:180
date::days
std::chrono::duration< int, detail::ratio_multiply< std::ratio< 24 >, std::chrono::hours::period > > days
Definition: date.h:177
date::sys_days
sys_time< days > sys_days
Definition: date.h:193
julian::literals::oct
CONSTDATA julian::month oct
Definition: julian.h:1361
julian::literals::jul
CONSTDATA julian::month jul
Definition: julian.h:1358
julian::literals::fri
CONSTDATA julian::weekday fri
Definition: julian.h:1370
julian::literals::apr
CONSTDATA julian::month apr
Definition: julian.h:1355
julian::literals::feb
CONSTDATA julian::month feb
Definition: julian.h:1353
julian::literals::sep
CONSTDATA julian::month sep
Definition: julian.h:1360
julian::literals::sun
CONSTDATA julian::weekday sun
Definition: julian.h:1365
julian::literals::dec
CONSTDATA julian::month dec
Definition: julian.h:1363
julian::literals::tue
CONSTDATA julian::weekday tue
Definition: julian.h:1367
julian::literals::jan
CONSTDATA julian::month jan
Definition: julian.h:1352
julian::literals::nov
CONSTDATA julian::month nov
Definition: julian.h:1362
julian::literals::mon
CONSTDATA julian::weekday mon
Definition: julian.h:1366
julian::literals::last
CONSTDATA julian::last_spec last
Definition: julian.h:1350
julian::literals::sat
CONSTDATA julian::weekday sat
Definition: julian.h:1371
julian::literals::thu
CONSTDATA julian::weekday thu
Definition: julian.h:1369
julian::literals::wed
CONSTDATA julian::weekday wed
Definition: julian.h:1368
julian::literals::aug
CONSTDATA julian::month aug
Definition: julian.h:1359
julian::literals::jun
CONSTDATA julian::month jun
Definition: julian.h:1357
julian::literals::mar
CONSTDATA julian::month mar
Definition: julian.h:1354
julian::literals::may
CONSTDATA julian::month may
Definition: julian.h:1356
julian
Definition: julian.h:33
julian::operator+
CONSTCD11 day operator+(const day &x, const days &y) NOEXCEPT
Definition: julian.h:856
julian::months
std::chrono::duration< int, date::detail::ratio_divide< years::period, std::ratio< 12 > > > months
Definition: julian.h:45
julian::operator>=
CONSTCD11 bool operator>=(const day &x, const day &y) NOEXCEPT
Definition: julian.h:839
julian::operator!=
CONSTCD11 bool operator!=(const day &x, const day &y) NOEXCEPT
Definition: julian.h:807
julian::operator>
CONSTCD11 bool operator>(const day &x, const day &y) NOEXCEPT
Definition: julian.h:823
julian::weeks
date::weeks weeks
Definition: julian.h:39
julian::sys_days
date::sys_days sys_days
Definition: julian.h:49
julian::days
date::days days
Definition: julian.h:37
julian::operator<<
std::basic_ostream< CharT, Traits > & operator<<(std::basic_ostream< CharT, Traits > &os, const day &d)
Definition: julian.h:880
julian::operator-
CONSTCD11 day operator-(const day &x, const days &y) NOEXCEPT
Definition: julian.h:872
julian::years
std::chrono::duration< int, date::detail::ratio_multiply< std::ratio< 1461, 4 >, days::period > > years
Definition: julian.h:42
julian::operator==
CONSTCD11 bool operator==(const day &x, const day &y) NOEXCEPT
Definition: julian.h:799
julian::operator/
CONSTCD11 year_month operator/(const year &y, const month &m) NOEXCEPT
Definition: julian.h:2723
julian::operator<=
CONSTCD11 bool operator<=(const day &x, const day &y) NOEXCEPT
Definition: julian.h:831
julian::local_days
date::local_days local_days
Definition: julian.h:50
julian::operator<
CONSTCD11 bool operator<(const day &x, const day &y) NOEXCEPT
Definition: julian.h:815
mu
Namespace for mathematical applications.
Definition: muParser.cpp:53
min
#define min(a, b)
Definition: resampler.cpp:34
max
#define max(a, b)
Definition: resampler.cpp:30
julian::last_spec
Definition: julian.h:55
julian::last_spec::last_spec
last_spec()=default