#ifndef DATE_H

#define DATE_H

// The MIT License (MIT)

//

// Copyright (c) 2015 Howard Hinnant

//

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to deal

// in the Software without restriction, including without limitation the rights

// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

// copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

//

// The above copyright notice and this permission notice shall be included in all

// copies or substantial portions of the Software.

//

// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

// SOFTWARE.

#include <chrono>

#include <climits>

#if !(__cplusplus >= 201402)

# include <cmath>

#endif

#include <limits>

#include <ostream>

#include <ratio>

#include <stdexcept>

namespace date

{

//---------------+

// Configuration |

//---------------+

// MSVC's constexpr support is still a WIP, even in VS2015.

// Fall back to a lesser mode to support it.

// TODO: Remove this or retest later once MSVC's constexpr improves.

#if defined(_MSC_VER)

# define CONSTDATA const

# define CONSTCD11

# define CONSTCD14

# define NOEXCEPT _NOEXCEPT

#elif __cplusplus >= 201402

# define CONSTDATA constexpr

# define CONSTCD11 constexpr

# define CONSTCD14 constexpr

# define NOEXCEPT noexcept

#else

# define CONSTDATA constexpr

# define CONSTCD11 constexpr

# define CONSTCD14

# define NOEXCEPT noexcept

#endif

//-----------+

// Interface |

//-----------+

// durations

using days = std::chrono::duration

<int, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period>>;

using weeks = std::chrono::duration

<int, std::ratio_multiply<std::ratio<7>, days::period>>;

using years = std::chrono::duration

<int, std::ratio_multiply<std::ratio<146097, 400>, days::period>>;

using months = std::chrono::duration

<int, std::ratio_divide<years::period, std::ratio<12>>>;

// time_point

using day_point = std::chrono::time_point<std::chrono::system_clock, days>;

// types

struct last_spec

{

explicit last_spec() = default;

};

class day;

class month;

class year;

class weekday;

class weekday_indexed;

class weekday_last;

class month_day;

class month_day_last;

class month_weekday;

class month_weekday_last;

class year_month;

class year_month_day;

class year_month_day_last;

class year_month_weekday;

class year_month_weekday_last;

// date composition operators

CONSTCD11 year_month operator/(const year& y, const month& m) NOEXCEPT;

CONSTCD11 year_month operator/(const year& y, int m) NOEXCEPT;

CONSTCD11 month_day operator/(const day& d, const month& m) NOEXCEPT;

CONSTCD11 month_day operator/(const day& d, int m) NOEXCEPT;

CONSTCD11 month_day operator/(const month& m, const day& d) NOEXCEPT;

CONSTCD11 month_day operator/(const month& m, int d) NOEXCEPT;

CONSTCD11 month_day operator/(int m, const day& d) NOEXCEPT;

CONSTCD11 month_day_last operator/(const month& m, last_spec) NOEXCEPT;

CONSTCD11 month_day_last operator/(int m, last_spec) NOEXCEPT;

CONSTCD11 month_day_last operator/(last_spec, const month& m) NOEXCEPT;

CONSTCD11 month_day_last operator/(last_spec, int m) NOEXCEPT;

CONSTCD11 month_weekday operator/(const month& m, const weekday_indexed& wdi) NOEXCEPT;

CONSTCD11 month_weekday operator/(int m, const weekday_indexed& wdi) NOEXCEPT;

CONSTCD11 month_weekday operator/(const weekday_indexed& wdi, const month& m) NOEXCEPT;

CONSTCD11 month_weekday operator/(const weekday_indexed& wdi, int m) NOEXCEPT;

CONSTCD11 month_weekday_last operator/(const month& m, const weekday_last& wdl) NOEXCEPT;

CONSTCD11 month_weekday_last operator/(int m, const weekday_last& wdl) NOEXCEPT;

CONSTCD11 month_weekday_last operator/(const weekday_last& wdl, const month& m) NOEXCEPT;

CONSTCD11 month_weekday_last operator/(const weekday_last& wdl, int m) NOEXCEPT;

CONSTCD11 year_month_day operator/(const year_month& ym, const day& d) NOEXCEPT;

CONSTCD11 year_month_day operator/(const year_month& ym, int d) NOEXCEPT;

CONSTCD11 year_month_day operator/(const year& y, const month_day& md) NOEXCEPT;

CONSTCD11 year_month_day operator/(int y, const month_day& md) NOEXCEPT;

CONSTCD11 year_month_day operator/(const month_day& md, const year& y) NOEXCEPT;

CONSTCD11 year_month_day operator/(const month_day& md, int y) NOEXCEPT;

CONSTCD11

year_month_day_last operator/(const year_month& ym, last_spec) NOEXCEPT;

CONSTCD11

year_month_day_last operator/(const year& y, const month_day_last& mdl) NOEXCEPT;

CONSTCD11

year_month_day_last operator/(int y, const month_day_last& mdl) NOEXCEPT;

CONSTCD11

year_month_day_last operator/(const month_day_last& mdl, const year& y) NOEXCEPT;

CONSTCD11

year_month_day_last operator/(const month_day_last& mdl, int y) NOEXCEPT;

CONSTCD11

year_month_weekday

operator/(const year_month& ym, const weekday_indexed& wdi) NOEXCEPT;

CONSTCD11

year_month_weekday

operator/(const year& y, const month_weekday& mwd) NOEXCEPT;

CONSTCD11

year_month_weekday

operator/(int y, const month_weekday& mwd) NOEXCEPT;

CONSTCD11

year_month_weekday

operator/(const month_weekday& mwd, const year& y) NOEXCEPT;

CONSTCD11

year_month_weekday

operator/(const month_weekday& mwd, int y) NOEXCEPT;

CONSTCD11

year_month_weekday_last

operator/(const year_month& ym, const weekday_last& wdl) NOEXCEPT;

CONSTCD11

year_month_weekday_last

operator/(const year& y, const month_weekday_last& mwdl) NOEXCEPT;

CONSTCD11

year_month_weekday_last

operator/(int y, const month_weekday_last& mwdl) NOEXCEPT;

CONSTCD11

year_month_weekday_last

operator/(const month_weekday_last& mwdl, const year& y) NOEXCEPT;

CONSTCD11

year_month_weekday_last

operator/(const month_weekday_last& mwdl, int y) NOEXCEPT;

// Detailed interface

// day

class day

{

unsigned char d_;

public:

explicit CONSTCD11 day(unsigned d) NOEXCEPT;

day& operator++() NOEXCEPT;

day operator++(int) NOEXCEPT;

day& operator--() NOEXCEPT;

day operator--(int) NOEXCEPT;

day& operator+=(const days& d) NOEXCEPT;

day& operator-=(const days& d) NOEXCEPT;

CONSTCD11 explicit operator unsigned() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11 bool operator==(const day& x, const day& y) NOEXCEPT;

CONSTCD11 bool operator!=(const day& x, const day& y) NOEXCEPT;

CONSTCD11 bool operator< (const day& x, const day& y) NOEXCEPT;

CONSTCD11 bool operator> (const day& x, const day& y) NOEXCEPT;

CONSTCD11 bool operator<=(const day& x, const day& y) NOEXCEPT;

CONSTCD11 bool operator>=(const day& x, const day& y) NOEXCEPT;

CONSTCD11 day operator+(const day& x, const days& y) NOEXCEPT;

CONSTCD11 day operator+(const days& x, const day& y) NOEXCEPT;

CONSTCD11 day operator-(const day& x, const days& y) NOEXCEPT;

CONSTCD11 days operator-(const day& x, const day& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const day& d);

// month

class month

{

unsigned char m_;

public:

explicit CONSTCD11 month(unsigned m) NOEXCEPT;

month& operator++() NOEXCEPT;

month operator++(int) NOEXCEPT;

month& operator--() NOEXCEPT;

month operator--(int) NOEXCEPT;

month& operator+=(const months& m) NOEXCEPT;

month& operator-=(const months& m) NOEXCEPT;

CONSTCD11 explicit operator unsigned() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11 bool operator==(const month& x, const month& y) NOEXCEPT;

CONSTCD11 bool operator!=(const month& x, const month& y) NOEXCEPT;

CONSTCD11 bool operator< (const month& x, const month& y) NOEXCEPT;

CONSTCD11 bool operator> (const month& x, const month& y) NOEXCEPT;

CONSTCD11 bool operator<=(const month& x, const month& y) NOEXCEPT;

CONSTCD11 bool operator>=(const month& x, const month& y) NOEXCEPT;

CONSTCD14 month operator+(const month& x, const months& y) NOEXCEPT;

CONSTCD14 month operator+(const months& x, const month& y) NOEXCEPT;

CONSTCD14 month operator-(const month& x, const months& y) NOEXCEPT;

CONSTCD14 months operator-(const month& x, const month& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const month& m);

// year

class year

{

short y_;

public:

explicit CONSTCD11 year(int y) NOEXCEPT;

year& operator++() NOEXCEPT;

year operator++(int) NOEXCEPT;

year& operator--() NOEXCEPT;

year operator--(int) NOEXCEPT;

year& operator+=(const years& y) NOEXCEPT;

year& operator-=(const years& y) NOEXCEPT;

CONSTCD11 bool is_leap() const NOEXCEPT;

CONSTCD11 explicit operator int() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

static CONSTCD11 year min() NOEXCEPT;

static CONSTCD11 year max() NOEXCEPT;

};

CONSTCD11 bool operator==(const year& x, const year& y) NOEXCEPT;

CONSTCD11 bool operator!=(const year& x, const year& y) NOEXCEPT;

CONSTCD11 bool operator< (const year& x, const year& y) NOEXCEPT;

CONSTCD11 bool operator> (const year& x, const year& y) NOEXCEPT;

CONSTCD11 bool operator<=(const year& x, const year& y) NOEXCEPT;

CONSTCD11 bool operator>=(const year& x, const year& y) NOEXCEPT;

CONSTCD11 year operator+(const year& x, const years& y) NOEXCEPT;

CONSTCD11 year operator+(const years& x, const year& y) NOEXCEPT;

CONSTCD11 year operator-(const year& x, const years& y) NOEXCEPT;

CONSTCD11 years operator-(const year& x, const year& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const year& y);

// weekday

class weekday

{

unsigned char wd_;

public:

explicit CONSTCD11 weekday(unsigned wd) NOEXCEPT;

explicit weekday(int) = delete;

CONSTCD11 weekday(const day_point& dp) NOEXCEPT;

weekday& operator++() NOEXCEPT;

weekday operator++(int) NOEXCEPT;

weekday& operator--() NOEXCEPT;

weekday operator--(int) NOEXCEPT;

weekday& operator+=(const days& d) NOEXCEPT;

weekday& operator-=(const days& d) NOEXCEPT;

CONSTCD11 explicit operator unsigned() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

CONSTCD11 weekday_indexed operator[](unsigned index) const NOEXCEPT;

CONSTCD11 weekday_last operator[](last_spec) const NOEXCEPT;

private:

static CONSTCD11 unsigned char weekday_from_days(int z) NOEXCEPT;

};

CONSTCD11 bool operator==(const weekday& x, const weekday& y) NOEXCEPT;

CONSTCD11 bool operator!=(const weekday& x, const weekday& y) NOEXCEPT;

CONSTCD14 weekday operator+(const weekday& x, const days& y) NOEXCEPT;

CONSTCD14 weekday operator+(const days& x, const weekday& y) NOEXCEPT;

CONSTCD14 weekday operator-(const weekday& x, const days& y) NOEXCEPT;

CONSTCD14 days operator-(const weekday& x, const weekday& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const weekday& wd);

// weekday_indexed

class weekday_indexed

{

unsigned char wd_ : 4;

unsigned char index_ : 4;

public:

CONSTCD11 weekday_indexed(const date::weekday& wd, unsigned index) NOEXCEPT;

CONSTCD11 date::weekday weekday() const NOEXCEPT;

CONSTCD11 unsigned index() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11 bool operator==(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT;

CONSTCD11 bool operator!=(const weekday_indexed& x, const weekday_indexed& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const weekday_indexed& wdi);

// weekday_last

class weekday_last

{

date::weekday wd_;

public:

explicit CONSTCD11 weekday_last(const date::weekday& wd) NOEXCEPT;

CONSTCD11 date::weekday weekday() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11 bool operator==(const weekday_last& x, const weekday_last& y) NOEXCEPT;

CONSTCD11 bool operator!=(const weekday_last& x, const weekday_last& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const weekday_last& wdl);

// year_month

class year_month

{

date::year y_;

date::month m_;

public:

CONSTCD11 year_month(const date::year& y, const date::month& m) NOEXCEPT;

CONSTCD11 date::year year() const NOEXCEPT;

CONSTCD11 date::month month() const NOEXCEPT;

year_month& operator+=(const months& dm) NOEXCEPT;

year_month& operator-=(const months& dm) NOEXCEPT;

year_month& operator+=(const years& dy) NOEXCEPT;

year_month& operator-=(const years& dy) NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11 bool operator==(const year_month& x, const year_month& y) NOEXCEPT;

CONSTCD11 bool operator!=(const year_month& x, const year_month& y) NOEXCEPT;

CONSTCD11 bool operator< (const year_month& x, const year_month& y) NOEXCEPT;

CONSTCD11 bool operator> (const year_month& x, const year_month& y) NOEXCEPT;

CONSTCD11 bool operator<=(const year_month& x, const year_month& y) NOEXCEPT;

CONSTCD11 bool operator>=(const year_month& x, const year_month& y) NOEXCEPT;

CONSTCD14 year_month operator+(const year_month& ym, const months& dm) NOEXCEPT;

CONSTCD14 year_month operator+(const months& dm, const year_month& ym) NOEXCEPT;

CONSTCD14 year_month operator-(const year_month& ym, const months& dm) NOEXCEPT;

CONSTCD11 months operator-(const year_month& x, const year_month& y) NOEXCEPT;

CONSTCD11 year_month operator+(const year_month& ym, const years& dy) NOEXCEPT;

CONSTCD11 year_month operator+(const years& dy, const year_month& ym) NOEXCEPT;

CONSTCD11 year_month operator-(const year_month& ym, const years& dy) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const year_month& ym);

// month_day

class month_day

{

date::month m_;

date::day d_;

public:

CONSTCD11 month_day(const date::month& m, const date::day& d) NOEXCEPT;

CONSTCD11 date::month month() const NOEXCEPT;

CONSTCD11 date::day day() const NOEXCEPT;

CONSTCD14 bool ok() const NOEXCEPT;

};

CONSTCD11 bool operator==(const month_day& x, const month_day& y) NOEXCEPT;

CONSTCD11 bool operator!=(const month_day& x, const month_day& y) NOEXCEPT;

CONSTCD11 bool operator< (const month_day& x, const month_day& y) NOEXCEPT;

CONSTCD11 bool operator> (const month_day& x, const month_day& y) NOEXCEPT;

CONSTCD11 bool operator<=(const month_day& x, const month_day& y) NOEXCEPT;

CONSTCD11 bool operator>=(const month_day& x, const month_day& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const month_day& md);

// month_day_last

class month_day_last

{

date::month m_;

public:

CONSTCD11 explicit month_day_last(const date::month& m) NOEXCEPT;

CONSTCD11 date::month month() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11 bool operator==(const month_day_last& x, const month_day_last& y) NOEXCEPT;

CONSTCD11 bool operator!=(const month_day_last& x, const month_day_last& y) NOEXCEPT;

CONSTCD11 bool operator< (const month_day_last& x, const month_day_last& y) NOEXCEPT;

CONSTCD11 bool operator> (const month_day_last& x, const month_day_last& y) NOEXCEPT;

CONSTCD11 bool operator<=(const month_day_last& x, const month_day_last& y) NOEXCEPT;

CONSTCD11 bool operator>=(const month_day_last& x, const month_day_last& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const month_day_last& mdl);

// month_weekday

class month_weekday

{

date::month m_;

date::weekday_indexed wdi_;

public:

CONSTCD11 month_weekday(const date::month& m,

const date::weekday_indexed& wdi) NOEXCEPT;

CONSTCD11 date::month month() const NOEXCEPT;

CONSTCD11 date::weekday_indexed weekday_indexed() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11 bool operator==(const month_weekday& x, const month_weekday& y) NOEXCEPT;

CONSTCD11 bool operator!=(const month_weekday& x, const month_weekday& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const month_weekday& mwd);

// month_weekday_last

class month_weekday_last

{

date::month m_;

date::weekday_last wdl_;

public:

CONSTCD11 month_weekday_last(const date::month& m,

const date::weekday_last& wd) NOEXCEPT;

CONSTCD11 date::month month() const NOEXCEPT;

CONSTCD11 date::weekday_last weekday_last() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11

bool operator==(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT;

CONSTCD11

bool operator!=(const month_weekday_last& x, const month_weekday_last& y) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const month_weekday_last& mwdl);

// class year_month_day

class year_month_day

{

date::year y_;

date::month m_;

date::day d_;

public:

CONSTCD11 year_month_day(const date::year& y, const date::month& m,

const date::day& d) NOEXCEPT;

CONSTCD14 year_month_day(const year_month_day_last& ymdl) NOEXCEPT;

CONSTCD14 year_month_day(const day_point& dp) NOEXCEPT;

year_month_day& operator+=(const months& m) NOEXCEPT;

year_month_day& operator-=(const months& m) NOEXCEPT;

year_month_day& operator+=(const years& y) NOEXCEPT;

year_month_day& operator-=(const years& y) NOEXCEPT;

CONSTCD11 date::year year() const NOEXCEPT;

CONSTCD11 date::month month() const NOEXCEPT;

CONSTCD11 date::day day() const NOEXCEPT;

CONSTCD14 operator day_point() const NOEXCEPT;

CONSTCD14 bool ok() const NOEXCEPT;

private:

static CONSTCD14 year_month_day from_day_point(const day_point& dp) NOEXCEPT;

};

CONSTCD11 bool operator==(const year_month_day& x, const year_month_day& y) NOEXCEPT;

CONSTCD11 bool operator!=(const year_month_day& x, const year_month_day& y) NOEXCEPT;

CONSTCD11 bool operator< (const year_month_day& x, const year_month_day& y) NOEXCEPT;

CONSTCD11 bool operator> (const year_month_day& x, const year_month_day& y) NOEXCEPT;

CONSTCD11 bool operator<=(const year_month_day& x, const year_month_day& y) NOEXCEPT;

CONSTCD11 bool operator>=(const year_month_day& x, const year_month_day& y) NOEXCEPT;

CONSTCD14 year_month_day operator+(const year_month_day& ymd, const months& dm) NOEXCEPT;

CONSTCD14 year_month_day operator+(const months& dm, const year_month_day& ymd) NOEXCEPT;

CONSTCD14 year_month_day operator-(const year_month_day& ymd, const months& dm) NOEXCEPT;

CONSTCD11 year_month_day operator+(const year_month_day& ymd, const years& dy) NOEXCEPT;

CONSTCD11 year_month_day operator+(const years& dy, const year_month_day& ymd) NOEXCEPT;

CONSTCD11 year_month_day operator-(const year_month_day& ymd, const years& dy) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const year_month_day& ymd);

// year_month_day_last

class year_month_day_last

{

date::year y_;

date::month_day_last mdl_;

public:

CONSTCD11 year_month_day_last(const date::year& y,

const date::month_day_last& mdl) NOEXCEPT;

year_month_day_last& operator+=(const months& m) NOEXCEPT;

year_month_day_last& operator-=(const months& m) NOEXCEPT;

year_month_day_last& operator+=(const years& y) NOEXCEPT;

year_month_day_last& operator-=(const years& y) NOEXCEPT;

CONSTCD11 date::year year() const NOEXCEPT;

CONSTCD11 date::month month() const NOEXCEPT;

CONSTCD11 date::month_day_last month_day_last() const NOEXCEPT;

CONSTCD14 date::day day() const NOEXCEPT;

CONSTCD14 operator day_point() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11

bool operator==(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;

CONSTCD11

bool operator!=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;

CONSTCD11

bool operator< (const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;

CONSTCD11

bool operator> (const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;

CONSTCD11

bool operator<=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;

CONSTCD11

bool operator>=(const year_month_day_last& x, const year_month_day_last& y) NOEXCEPT;

CONSTCD14

year_month_day_last

operator+(const year_month_day_last& ymdl, const months& dm) NOEXCEPT;

CONSTCD14

year_month_day_last

operator+(const months& dm, const year_month_day_last& ymdl) NOEXCEPT;

CONSTCD11

year_month_day_last

operator+(const year_month_day_last& ymdl, const years& dy) NOEXCEPT;

CONSTCD11

year_month_day_last

operator+(const years& dy, const year_month_day_last& ymdl) NOEXCEPT;

CONSTCD14

year_month_day_last

operator-(const year_month_day_last& ymdl, const months& dm) NOEXCEPT;

CONSTCD11

year_month_day_last

operator-(const year_month_day_last& ymdl, const years& dy) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const year_month_day_last& ymdl);

// year_month_weekday

class year_month_weekday

{

date::year y_;

date::month m_;

date::weekday_indexed wdi_;

public:

CONSTCD11 year_month_weekday(const date::year& y, const date::month& m,

const date::weekday_indexed& wdi) NOEXCEPT;

CONSTCD14 year_month_weekday(const day_point& dp) NOEXCEPT;

year_month_weekday& operator+=(const months& m) NOEXCEPT;

year_month_weekday& operator-=(const months& m) NOEXCEPT;

year_month_weekday& operator+=(const years& y) NOEXCEPT;

year_month_weekday& operator-=(const years& y) NOEXCEPT;

CONSTCD11 date::year year() const NOEXCEPT;

CONSTCD11 date::month month() const NOEXCEPT;

CONSTCD11 date::weekday weekday() const NOEXCEPT;

CONSTCD11 unsigned index() const NOEXCEPT;

CONSTCD11 date::weekday_indexed weekday_indexed() const NOEXCEPT;

CONSTCD14 operator day_point() const NOEXCEPT;

CONSTCD14 bool ok() const NOEXCEPT;

private:

static CONSTCD14 year_month_weekday from_day_point(const day_point& dp) NOEXCEPT;

};

CONSTCD11

bool operator==(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT;

CONSTCD11

bool operator!=(const year_month_weekday& x, const year_month_weekday& y) NOEXCEPT;

CONSTCD14

year_month_weekday

operator+(const year_month_weekday& ymwd, const months& dm) NOEXCEPT;

CONSTCD14

year_month_weekday

operator+(const months& dm, const year_month_weekday& ymwd) NOEXCEPT;

CONSTCD11

year_month_weekday

operator+(const year_month_weekday& ymwd, const years& dy) NOEXCEPT;

CONSTCD11

year_month_weekday

operator+(const years& dy, const year_month_weekday& ymwd) NOEXCEPT;

CONSTCD14

year_month_weekday

operator-(const year_month_weekday& ymwd, const months& dm) NOEXCEPT;

CONSTCD11

year_month_weekday

operator-(const year_month_weekday& ymwd, const years& dy) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const year_month_weekday& ymwdi);

// year_month_weekday_last

class year_month_weekday_last

{

date::year y_;

date::month m_;

date::weekday_last wdl_;

public:

CONSTCD11 year_month_weekday_last(const date::year& y, const date::month& m,

const date::weekday_last& wdl) NOEXCEPT;

year_month_weekday_last& operator+=(const months& m) NOEXCEPT;

year_month_weekday_last& operator-=(const months& m) NOEXCEPT;

year_month_weekday_last& operator+=(const years& y) NOEXCEPT;

year_month_weekday_last& operator-=(const years& y) NOEXCEPT;

CONSTCD11 date::year year() const NOEXCEPT;

CONSTCD11 date::month month() const NOEXCEPT;

CONSTCD11 date::weekday weekday() const NOEXCEPT;

CONSTCD11 date::weekday_last weekday_last() const NOEXCEPT;

CONSTCD14 operator day_point() const NOEXCEPT;

CONSTCD11 bool ok() const NOEXCEPT;

};

CONSTCD11

bool

operator==(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT;

CONSTCD11

bool

operator!=(const year_month_weekday_last& x, const year_month_weekday_last& y) NOEXCEPT;

CONSTCD14

year_month_weekday_last

operator+(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT;

CONSTCD14

year_month_weekday_last

operator+(const months& dm, const year_month_weekday_last& ymwdl) NOEXCEPT;

CONSTCD11

year_month_weekday_last

operator+(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT;

CONSTCD11

year_month_weekday_last

operator+(const years& dy, const year_month_weekday_last& ymwdl) NOEXCEPT;

CONSTCD14

year_month_weekday_last

operator-(const year_month_weekday_last& ymwdl, const months& dm) NOEXCEPT;

CONSTCD11

year_month_weekday_last

operator-(const year_month_weekday_last& ymwdl, const years& dy) NOEXCEPT;

std::ostream& operator<<(std::ostream& os, const year_month_weekday_last& ymwdl);

#if !defined(_MSC_VER) || (_MSC_VER >= 1900)

inline namespace literals

{

CONSTCD11 date::day operator "" _d(unsigned long long d) NOEXCEPT;

CONSTCD11 date::year operator "" _y(unsigned long long y) NOEXCEPT;

// CONSTDATA date::month jan{1};

// CONSTDATA date::month feb{2};

// CONSTDATA date::month mar{3};

// CONSTDATA date::month apr{4};

// CONSTDATA date::month may{5};

// CONSTDATA date::month jun{6};

// CONSTDATA date::month jul{7};

// CONSTDATA date::month aug{8};

// CONSTDATA date::month sep{9};

// CONSTDATA date::month oct{10};

// CONSTDATA date::month nov{11};

// CONSTDATA date::month dec{12};

//

// CONSTDATA date::weekday sun{0u};

// CONSTDATA date::weekday mon{1u};

// CONSTDATA date::weekday tue{2u};

// CONSTDATA date::weekday wed{3u};

// CONSTDATA date::weekday thu{4u};

// CONSTDATA date::weekday fri{5u};

// CONSTDATA date::weekday sat{6u};

} // inline namespace literals

#endif // !defined(_MSC_VER) || (_MSC_VER >= 1900)

//----------------+

// Implementation |

//----------------+

// utilities

namespace detail {

class save_stream

{

std::ostream& os_;

char fill_;

std::ios::fmtflags flags_;

public:

~save_stream()

{

os_.fill(fill_);

os_.flags(flags_);

}

save_stream(const save_stream&) = delete;

save_stream& operator=(const save_stream&) = delete;

explicit save_stream(std::ostream& os)

: os_(os)

, fill_(os.fill())

, flags_(os.flags())

{}

};

#ifdef __GNUC__

// GCC complains about __int128 with -pedantic or -pedantic-errors

#pragma GCC diagnostic push

#pragma GCC diagnostic ignored "-Wpedantic"

#endif

template <class T>

struct choose_trunc_type

{

static const int digits = std::numeric_limits<T>::digits;

using type = typename std::conditional

<

digits < 32,

std::int32_t,

typename std::conditional

<

digits < 64,

std::int64_t,

#ifdef __SIZEOF_INT128__

__int128

#else

std::int64_t

#endif

>::type

>::type;

};

#ifdef __GNUC__

#pragma GCC diagnostic pop

#endif

template <class T>

CONSTCD11

inline

typename std::enable_if

<

!std::chrono::treat_as_floating_point<T>::value,

T

>::type

trunc(T t) NOEXCEPT

{

return t;

}

template <class T>

CONSTCD14

inline

typename std::enable_if

<

std::chrono::treat_as_floating_point<T>::value,

T

>::type

trunc(T t) NOEXCEPT

{

using namespace std;

using I = typename choose_trunc_type<T>::type;

CONSTDATA auto digits = numeric_limits<T>::digits;

static_assert(digits < numeric_limits<I>::digits, "");

CONSTDATA auto max = I{1} << (digits-1);

CONSTDATA auto min = -max;

const auto negative = t < T{0};

if (min <= t && t <= max && t != 0 && t == t)

{

t = static_cast<T>(static_cast<I>(t));

if (t == 0 && negative)

t = -t;

}

return t;

}

} // detail

// trunc towards zero

template <class To, class Rep, class Period>

CONSTCD11

inline

To

trunc(const std::chrono::duration<Rep, Period>& d)

{

return To{detail::trunc(std::chrono::duration_cast<To>(d).count())};

}

// round down

template <class To, class Rep, class Period>

CONSTCD14

inline

To

floor(const std::chrono::duration<Rep, Period>& d)

{

auto t = trunc<To>(d);

if (t > d)

return t - To{1};

return t;

}

// round to nearest, to even on tie

template <class To, class Rep, class Period>

CONSTCD14

inline

To

round(const std::chrono::duration<Rep, Period>& d)

{

auto t0 = floor<To>(d);

auto t1 = t0 + To{1};

if (t1 == To{0} && t0 < To{0})

t1 = -t1;

auto diff0 = d - t0;

auto diff1 = t1 - d;

if (diff0 == diff1)

{

if (t0 - trunc<To>(t0/2)*2 == To{0})

return t0;

return t1;

}

if (diff0 < diff1)

return t0;

return t1;

}

// round up

template <class To, class Rep, class Period>

CONSTCD14

inline

To

ceil(const std::chrono::duration<Rep, Period>& d)

{

auto t = trunc<To>(d);

if (t < d)

return t + To{1};

return t;

}

template <class Rep, class Period,

class = typename std::enable_if

<

std::numeric_limits<Rep>::is_signed

>::type>

CONSTCD11

std::chrono::duration<Rep, Period>

abs(std::chrono::duration<Rep, Period> d)

{

return d >= d.zero() ? d : -d;

}

// trunc towards zero

template <class To, class Clock, class FromDuration>

CONSTCD11

inline

std::chrono::time_point<Clock, To>

trunc(const std::chrono::time_point<Clock, FromDuration>& tp)

{

using std::chrono::time_point;

return time_point<Clock, To>{trunc<To>(tp.time_since_epoch())};

}

// round down

template <class To, class Clock, class FromDuration>

CONSTCD11

inline

std::chrono::time_point<Clock, To>

floor(const std::chrono::time_point<Clock, FromDuration>& tp)

{

using std::chrono::time_point;

return time_point<Clock, To>{floor<To>(tp.time_since_epoch())};

}

// round to nearest, to even on tie

template <class To, class Clock, class FromDuration>

CONSTCD11

inline

std::chrono::time_point<Clock, To>

round(const std::chrono::time_point<Clock, FromDuration>& tp)

{

using std::chrono::time_point;

return time_point<Clock, To>{round<To>(tp.time_since_epoch())};

}

// round up

template <class To, class Clock, class FromDuration>

CONSTCD11

inline

std::chrono::time_point<Clock, To>

ceil(const std::chrono::time_point<Clock, FromDuration>& tp)

{

using std::chrono::time_point;

return time_point<Clock, To>{ceil<To>(tp.time_since_epoch())};

}

// day

CONSTCD11 inline day::day(unsigned d) NOEXCEPT : d_(static_cast<unsigned char>(d)) {}

inline day& day::operator++() NOEXCEPT {++d_; return *this;}

inline day day::operator++(int) NOEXCEPT {auto tmp(*this); ++(*this); return tmp;}