date Namespace Reference

Namespaces
	clock_cast_detail
	ctc_detail
	detail
	literals

Classes
class	ambiguous_local_time
struct	clock_time_conversion
struct	clock_time_conversion< Clock, Clock >
struct	clock_time_conversion< DstClock, std::chrono::system_clock >
struct	clock_time_conversion< DstClock, utc_clock >
struct	clock_time_conversion< std::chrono::system_clock, SrcClock >
struct	clock_time_conversion< std::chrono::system_clock, std::chrono::system_clock >
struct	clock_time_conversion< std::chrono::system_clock, utc_clock >
struct	clock_time_conversion< utc_clock, SrcClock >
struct	clock_time_conversion< utc_clock, std::chrono::system_clock >
struct	clock_time_conversion< utc_clock, utc_clock >
class	day
struct	fields
struct	find_rule_by_name
class	gps_clock
struct	last_spec
class	leap
class	link
struct	local_info
struct	local_t
class	month
class	month_day
class	month_day_last
class	month_weekday
class	month_weekday_last
class	nonexistent_local_time
struct	parse_manip
struct	sys_info
class	tai_clock
class	time_of_day
class	time_zone
struct	tzdb
class	tzdb_list
class	utc_clock
class	weekday
class	weekday_indexed
class	weekday_last
class	year
class	year_month
class	year_month_day
class	year_month_day_last
class	year_month_weekday
class	year_month_weekday_last
class	zoned_time
struct	zoned_traits
struct	zoned_traits< const time_zone * >
struct	zoned_traits< Posix::time_zone >

Typedefs
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 > >>
template<class Duration >
using	sys_time = std::chrono::time_point< std::chrono::system_clock, Duration >
using	sys_days = sys_time< days >
using	sys_seconds = sys_time< std::chrono::seconds >
template<class Duration >
using	local_time = std::chrono::time_point< local_t, Duration >
using	local_seconds = local_time< std::chrono::seconds >
using	local_days = local_time< days >
using	zoned_seconds = zoned_time< std::chrono::seconds >
using	TZ_DB = tzdb
template<class Duration >
using	utc_time = std::chrono::time_point< utc_clock, Duration >
using	utc_seconds = utc_time< std::chrono::seconds >
template<class Duration >
using	tai_time = std::chrono::time_point< tai_clock, Duration >
using	tai_seconds = tai_time< std::chrono::seconds >
template<class Duration >
using	gps_time = std::chrono::time_point< gps_clock, Duration >
using	gps_seconds = gps_time< std::chrono::seconds >

Enumerations
enum	{ am = 1, pm }
enum	choose { choose::earliest, choose::latest }

Functions
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
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const day &d)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const month &m)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const year &y)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const weekday &wd)
CONSTCD11 bool	operator== (const weekday_indexed &x, const weekday_indexed &y) NOEXCEPT
CONSTCD11 bool	operator!= (const weekday_indexed &x, const weekday_indexed &y) NOEXCEPT
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const weekday_indexed &wdi)
CONSTCD11 bool	operator== (const weekday_last &x, const weekday_last &y) NOEXCEPT
CONSTCD11 bool	operator!= (const weekday_last &x, const weekday_last &y) NOEXCEPT
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const weekday_last &wdl)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const year_month &ym)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const month_day &md)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const month_day_last &mdl)
CONSTCD11 bool	operator== (const month_weekday &x, const month_weekday &y) NOEXCEPT
CONSTCD11 bool	operator!= (const month_weekday &x, const month_weekday &y) NOEXCEPT
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const month_weekday &mwd)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const month_weekday_last &mwdl)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const year_month_day &ymd)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const year_month_day_last &ymdl)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const year_month_weekday &ymwdi)
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
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const year_month_weekday_last &ymwdl)
template<class To , class Rep , class Period >
CONSTCD11 std::enable_if< detail::no_overflow< Period, typename To::period >::value, To >::type	trunc (const std::chrono::duration< Rep, Period > &d)
template<class To , class Rep , class Period >
CONSTCD11 std::enable_if< !detail::no_overflow< Period, typename To::period >::value, To >::type	trunc (const std::chrono::duration< Rep, Period > &d)
template<class To , class Rep , class Period >
CONSTCD14 std::enable_if< detail::no_overflow< Period, typename To::period >::value, To >::type	floor (const std::chrono::duration< Rep, Period > &d)
template<class To , class Rep , class Period >
CONSTCD14 std::enable_if< !detail::no_overflow< Period, typename To::period >::value, To >::type	floor (const std::chrono::duration< Rep, Period > &d)
template<class To , class Rep , class Period >
CONSTCD14 To	round (const std::chrono::duration< Rep, Period > &d)
template<class To , class Rep , class Period >
CONSTCD14 To	ceil (const std::chrono::duration< Rep, Period > &d)
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)
template<class To , class Clock , class FromDuration >
CONSTCD11 std::chrono::time_point< Clock, To >	floor (const std::chrono::time_point< Clock, FromDuration > &tp)
template<class To , class Clock , class FromDuration >
CONSTCD11 std::chrono::time_point< Clock, To >	round (const std::chrono::time_point< Clock, FromDuration > &tp)
template<class To , class Clock , class FromDuration >
CONSTCD11 std::chrono::time_point< Clock, To >	ceil (const std::chrono::time_point< Clock, FromDuration > &tp)
template<class To , class Clock , class FromDuration >
CONSTCD11 std::chrono::time_point< Clock, To >	trunc (const std::chrono::time_point< Clock, FromDuration > &tp)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const fields< Duration > &fds, const std::string *abbrev=nullptr, const std::chrono::seconds *offset_sec=nullptr)
template<class CharT , class Traits , class Duration , class Alloc >
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, fields< Duration > &fds, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class Rep , class Period , class = typename std::enable_if <!std::chrono::treat_as_floating_point<Rep>::value>::type>
CONSTCD11 time_of_day< std::chrono::duration< Rep, Period > >	make_time (const std::chrono::duration< Rep, Period > &d)
CONSTCD11 time_of_day< std::chrono::hours >	make_time (const std::chrono::hours &h, unsigned md)
CONSTCD11 time_of_day< std::chrono::minutes >	make_time (const std::chrono::hours &h, const std::chrono::minutes &m, unsigned md)
CONSTCD11 time_of_day< std::chrono::seconds >	make_time (const std::chrono::hours &h, const std::chrono::minutes &m, const std::chrono::seconds &s, unsigned md)
template<class Rep , class Period , class = typename std::enable_if<std::ratio_less<Period, std::ratio<1>>::value>::type>
CONSTCD11 time_of_day< std::chrono::duration< Rep, Period > >	make_time (const std::chrono::hours &h, const std::chrono::minutes &m, const std::chrono::seconds &s, const std::chrono::duration< Rep, Period > &sub_s, unsigned md)
template<class CharT , class Traits , class Duration >
std::enable_if< !std::chrono::treat_as_floating_point< typename Duration::rep >::value &&std::ratio_less< typename Duration::period, days::period >::value, std::basic_ostream< CharT, Traits > & >::type	operator<< (std::basic_ostream< CharT, Traits > &os, const sys_time< Duration > &tp)
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const sys_days &dp)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const local_time< Duration > &ut)
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const year &y)
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const month &m)
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const day &d)
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const weekday &wd)
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const year_month &ym)
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const month_day &md)
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const year_month_day &ymd)
template<class CharT , class Traits , class Rep , class Period >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const std::chrono::duration< Rep, Period > &d)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const local_time< Duration > &tp, const std::string *abbrev=nullptr, const std::chrono::seconds *offset_sec=nullptr)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const sys_time< Duration > &tp)
template<class CharT , class Streamable >
auto	format (const std::locale &loc, const CharT *fmt, const Streamable &tp) -> decltype(to_stream(std::declval< std::basic_ostream< CharT > &>(), fmt, tp), std::basic_string< CharT >
os	exceptions (std::ios::failbit|std::ios::badbit)
os	imbue (loc)
	to_stream (os, fmt, tp)
return os	str ()
template<class CharT , class Streamable >
auto	format (const CharT *fmt, const Streamable &tp) -> decltype(to_stream(std::declval< std::basic_ostream< CharT > &>(), fmt, tp), std::basic_string< CharT >
template<class CharT , class Traits , class Alloc , class Streamable >
auto	format (const std::locale &loc, const std::basic_string< CharT, Traits, Alloc > &fmt, const Streamable &tp) -> decltype(to_stream(std::declval< std::basic_ostream< CharT, Traits > &>(), fmt.c_str(), tp), std::basic_string< CharT, Traits, Alloc >
	to_stream (os, fmt.c_str(), tp)
template<class CharT , class Traits , class Alloc , class Streamable >
auto	format (const std::basic_string< CharT, Traits, Alloc > &fmt, const Streamable &tp) -> decltype(to_stream(std::declval< std::basic_ostream< CharT, Traits > &>(), fmt.c_str(), tp), std::basic_string< CharT, Traits, Alloc >
template<class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, year &y, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, month &m, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, day &d, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, weekday &wd, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, year_month &ym, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, month_day &md, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, year_month_day &ymd, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, sys_time< Duration > &tp, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, local_time< Duration > &tp, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class Rep , class Period , class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, std::chrono::duration< Rep, Period > &d, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class Parsable , class CharT , class Traits , class Alloc >
std::basic_istream< CharT, Traits > &	operator>> (std::basic_istream< CharT, Traits > &is, const parse_manip< Parsable, CharT, Traits, Alloc > &x)
template<class Parsable , class CharT , class Traits , class Alloc >
auto	parse (const std::basic_string< CharT, Traits, Alloc > &format, Parsable &tp) -> decltype(from_stream(std::declval< std::basic_istream< CharT, Traits > &>(), format.c_str(), tp), parse_manip< Parsable, CharT, Traits, Alloc >
template<class Parsable , class CharT , class Traits , class Alloc >
auto	parse (const std::basic_string< CharT, Traits, Alloc > &format, Parsable &tp, std::basic_string< CharT, Traits, Alloc > &abbrev) -> decltype(from_stream(std::declval< std::basic_istream< CharT, Traits > &>(), format.c_str(), tp, &abbrev), parse_manip< Parsable, CharT, Traits, Alloc >
template<class Parsable , class CharT , class Traits , class Alloc >
auto	parse (const std::basic_string< CharT, Traits, Alloc > &format, Parsable &tp, std::chrono::minutes &offset) -> decltype(from_stream(std::declval< std::basic_istream< CharT, Traits > &>(), format.c_str(), tp, nullptr, &offset), parse_manip< Parsable, CharT, Traits, Alloc >
template<class Parsable , class CharT , class Traits , class Alloc >
auto	parse (const std::basic_string< CharT, Traits, Alloc > &format, Parsable &tp, std::basic_string< CharT, Traits, Alloc > &abbrev, std::chrono::minutes &offset) -> decltype(from_stream(std::declval< std::basic_istream< CharT, Traits > &>(), format.c_str(), tp, &abbrev, &offset), parse_manip< Parsable, CharT, Traits, Alloc >
template<class Parsable , class CharT >
auto	parse (const CharT *format, Parsable &tp) -> decltype(from_stream(std::declval< std::basic_istream< CharT > &>(), format, tp), parse_manip< Parsable, CharT >
template<class Parsable , class CharT , class Traits , class Alloc >
auto	parse (const CharT *format, Parsable &tp, std::basic_string< CharT, Traits, Alloc > &abbrev) -> decltype(from_stream(std::declval< std::basic_istream< CharT, Traits > &>(), format, tp, &abbrev), parse_manip< Parsable, CharT, Traits, Alloc >
template<class Parsable , class CharT >
auto	parse (const CharT *format, Parsable &tp, std::chrono::minutes &offset) -> decltype(from_stream(std::declval< std::basic_istream< CharT > &>(), format, tp, nullptr, &offset), parse_manip< Parsable, CharT >
template<class Parsable , class CharT , class Traits , class Alloc >
auto	parse (const CharT *format, Parsable &tp, std::basic_string< CharT, Traits, Alloc > &abbrev, std::chrono::minutes &offset) -> decltype(from_stream(std::declval< std::basic_istream< CharT, Traits > &>(), format, tp, &abbrev, &offset), parse_manip< Parsable, CharT, Traits, Alloc >
template<class CharT , class Traits , class Rep , class Period >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const std::chrono::duration< Rep, Period > &d)
void	set_install (const std::string &s)
tzdb_list &	get_tzdb_list ()
std::ostream &	operator<< (std::ostream &os, const time_zone &z)
std::ostream &	operator<< (std::ostream &os, const leap &x)
std::ostream &	operator<< (std::ostream &os, const link &x)
std::string	remote_version ()
bool	remote_download (const std::string &version)
bool	remote_install (const std::string &version)
const tzdb &	reload_tzdb ()
const tzdb &	get_tzdb ()
const time_zone *	locate_zone (const std::string &tz_name)
std::ostream &	operator<< (std::ostream &os, const tzdb &db)
const time_zone *	current_zone ()
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const sys_info &r)
template<class CharT , class Traits >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const local_info &r)
template<class Duration1 , class Duration2 , class TimeZonePtr >
bool	operator== (const zoned_time< Duration1, TimeZonePtr > &x, const zoned_time< Duration2, TimeZonePtr > &y)
template<class Duration1 , class Duration2 , class TimeZonePtr >
bool	operator!= (const zoned_time< Duration1, TimeZonePtr > &x, const zoned_time< Duration2, TimeZonePtr > &y)
bool	operator== (const time_zone &x, const time_zone &y) NOEXCEPT
bool	operator< (const time_zone &x, const time_zone &y) NOEXCEPT
bool	operator!= (const time_zone &x, const time_zone &y) NOEXCEPT
bool	operator> (const time_zone &x, const time_zone &y) NOEXCEPT
bool	operator<= (const time_zone &x, const time_zone &y) NOEXCEPT
bool	operator>= (const time_zone &x, const time_zone &y) NOEXCEPT
bool	operator!= (const link &x, const link &y)
bool	operator> (const link &x, const link &y)
bool	operator<= (const link &x, const link &y)
bool	operator>= (const link &x, const link &y)
bool	operator!= (const leap &x, const leap &y)
bool	operator> (const leap &x, const leap &y)
bool	operator<= (const leap &x, const leap &y)
bool	operator>= (const leap &x, const leap &y)
template<class Duration >
bool	operator== (const sys_time< Duration > &x, const leap &y)
template<class Duration >
bool	operator!= (const leap &x, const sys_time< Duration > &y)
template<class Duration >
bool	operator!= (const sys_time< Duration > &x, const leap &y)
template<class Duration >
bool	operator> (const leap &x, const sys_time< Duration > &y)
template<class Duration >
bool	operator> (const sys_time< Duration > &x, const leap &y)
template<class Duration >
bool	operator<= (const leap &x, const sys_time< Duration > &y)
template<class Duration >
bool	operator<= (const sys_time< Duration > &x, const leap &y)
template<class Duration >
bool	operator>= (const leap &x, const sys_time< Duration > &y)
template<class Duration >
bool	operator>= (const sys_time< Duration > &x, const leap &y)
zoned_time< std::chrono::seconds >	make_zoned ()
template<class Duration >
zoned_time< typename std::common_type< Duration, std::chrono::seconds >::type >	make_zoned (const sys_time< Duration > &tp)
template<class TimeZonePtr , class = typename std::enable_if < std::is_class < typename std::decay < decltype(*detail::to_raw_pointer(std::declval<TimeZonePtr&>())) >::type >{} >::type>
zoned_time< std::chrono::seconds, TimeZonePtr >	make_zoned (TimeZonePtr z)
zoned_seconds	make_zoned (const std::string &name)
template<class Duration , class TimeZonePtr , class = typename std::enable_if < std::is_class<typename std::decay<decltype(*std::declval<TimeZonePtr&>())>::type>{} >::type>
zoned_time< typename std::common_type< Duration, std::chrono::seconds >::type, TimeZonePtr >	make_zoned (TimeZonePtr zone, const local_time< Duration > &tp)
template<class Duration , class TimeZonePtr , class = typename std::enable_if < std::is_class<typename std::decay<decltype(*std::declval<TimeZonePtr&>())>::type>{} >::type>
zoned_time< typename std::common_type< Duration, std::chrono::seconds >::type, TimeZonePtr >	make_zoned (TimeZonePtr zone, const local_time< Duration > &tp, choose c)
template<class Duration >
zoned_time< typename std::common_type< Duration, std::chrono::seconds >::type >	make_zoned (const std::string &name, const local_time< Duration > &tp)
template<class Duration >
zoned_time< typename std::common_type< Duration, std::chrono::seconds >::type >	make_zoned (const std::string &name, const local_time< Duration > &tp, choose c)
template<class Duration , class TimeZonePtr >
zoned_time< Duration, TimeZonePtr >	make_zoned (TimeZonePtr zone, const zoned_time< Duration, TimeZonePtr > &zt)
template<class Duration , class TimeZonePtr >
zoned_time< Duration, TimeZonePtr >	make_zoned (const std::string &name, const zoned_time< Duration, TimeZonePtr > &zt)
template<class Duration , class TimeZonePtr >
zoned_time< Duration, TimeZonePtr >	make_zoned (TimeZonePtr zone, const zoned_time< Duration, TimeZonePtr > &zt, choose c)
template<class Duration , class TimeZonePtr >
zoned_time< Duration, TimeZonePtr >	make_zoned (const std::string &name, const zoned_time< Duration, TimeZonePtr > &zt, choose c)
template<class Duration , class TimeZonePtr , class = typename std::enable_if < std::is_class<typename std::decay<decltype(*std::declval<TimeZonePtr&>())>::type>{} >::type>
zoned_time< typename std::common_type< Duration, std::chrono::seconds >::type, TimeZonePtr >	make_zoned (TimeZonePtr zone, const sys_time< Duration > &st)
template<class Duration >
zoned_time< typename std::common_type< Duration, std::chrono::seconds >::type >	make_zoned (const std::string &name, const sys_time< Duration > &st)
template<class CharT , class Traits , class Duration , class TimeZonePtr >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const zoned_time< Duration, TimeZonePtr > &tp)
template<class CharT , class Traits , class Duration , class TimeZonePtr >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const zoned_time< Duration, TimeZonePtr > &t)
template<class Duration >
std::pair< bool, std::chrono::seconds >	is_leap_second (date::utc_time< Duration > const &ut)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const utc_time< Duration > &t)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const utc_time< Duration > &t)
template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, utc_time< Duration > &tp, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const tai_time< Duration > &t)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const tai_time< Duration > &t)
template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, tai_time< Duration > &tp, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	to_stream (std::basic_ostream< CharT, Traits > &os, const CharT *fmt, const gps_time< Duration > &t)
template<class CharT , class Traits , class Duration >
std::basic_ostream< CharT, Traits > &	operator<< (std::basic_ostream< CharT, Traits > &os, const gps_time< Duration > &t)
template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>
std::basic_istream< CharT, Traits > &	from_stream (std::basic_istream< CharT, Traits > &is, const CharT *fmt, gps_time< Duration > &tp, std::basic_string< CharT, Traits, Alloc > *abbrev=nullptr, std::chrono::minutes *offset=nullptr)
template<class DstClock , class SrcClock , class Duration >
auto	clock_cast (const std::chrono::time_point< SrcClock, Duration > &tp) -> decltype(clock_cast_detail::cc_impl< DstClock >(tp, &tp))
template<class Duration >
sys_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_sys_time (const utc_time< Duration > &t)
template<class Duration >
sys_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_sys_time (const tai_time< Duration > &t)
template<class Duration >
sys_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_sys_time (const gps_time< Duration > &t)
template<class Duration >
utc_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_utc_time (const sys_time< Duration > &t)
template<class Duration >
utc_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_utc_time (const tai_time< Duration > &t)
template<class Duration >
utc_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_utc_time (const gps_time< Duration > &t)
template<class Duration >
tai_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_tai_time (const sys_time< Duration > &t)
template<class Duration >
tai_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_tai_time (const utc_time< Duration > &t)
template<class Duration >
tai_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_tai_time (const gps_time< Duration > &t)
template<class Duration >
gps_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_gps_time (const sys_time< Duration > &t)
template<class Duration >
gps_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_gps_time (const utc_time< Duration > &t)
template<class Duration >
gps_time< typename std::common_type< Duration, std::chrono::seconds >::type >	to_gps_time (const tai_time< Duration > &t)

Variables
CONSTDATA auto	min_year = date::year::min()
CONSTDATA auto	max_year = date::year::max()
CONSTDATA auto	min_day = date::jan/1
CONSTDATA auto	max_day = date::dec/31

Typedef Documentation

days

using date::days = typedef std::chrono::duration <int, std::ratio_multiply<std::ratio<24>, std::chrono::hours::period> >

gps_seconds

using date::gps_seconds = typedef gps_time<std::chrono::seconds>

gps_time

template<class Duration >

using date::gps_time = typedef std::chrono::time_point<gps_clock, Duration>

local_days

using date::local_days = typedef local_time<days>

local_seconds

using date::local_seconds = typedef local_time<std::chrono::seconds>

local_time

template<class Duration >

using date::local_time = typedef std::chrono::time_point<local_t, Duration>

months

using date::months = typedef std::chrono::duration <int, std::ratio_divide<years::period, std::ratio<12> >>

sys_days

using date::sys_days = typedef sys_time<days>

sys_seconds

using date::sys_seconds = typedef sys_time<std::chrono::seconds>

sys_time

template<class Duration >

using date::sys_time = typedef std::chrono::time_point<std::chrono::system_clock, Duration>

tai_seconds

using date::tai_seconds = typedef tai_time<std::chrono::seconds>

tai_time

template<class Duration >

using date::tai_time = typedef std::chrono::time_point<tai_clock, Duration>

TZ_DB

using date::TZ_DB = typedef tzdb

utc_seconds

using date::utc_seconds = typedef utc_time<std::chrono::seconds>

utc_time

template<class Duration >

using date::utc_time = typedef std::chrono::time_point<utc_clock, Duration>

weeks

using date::weeks = typedef std::chrono::duration <int, std::ratio_multiply<std::ratio<7>, days::period> >

years

using date::years = typedef std::chrono::duration <int, std::ratio_multiply<std::ratio<146097, 400>, days::period> >

zoned_seconds

using date::zoned_seconds = typedef zoned_time<std::chrono::seconds>

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
am
pm

choose

enum date::choose

strong

Enumerator
earliest
latest

Function Documentation

abs()

template<class Rep , class Period , class = typename std::enable_if < std::numeric_limits<Rep>::is_signed >::type>

CONSTCD11 std::chrono::duration<Rep, Period> date::abs

(

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

d

)

ceil() [1/2]

template<class To , class Rep , class Period >

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

inline

ceil() [2/2]

template<class To , class Clock , class FromDuration >

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

inline

clock_cast()

template<class DstClock , class SrcClock , class Duration >

auto date::clock_cast

(

const std::chrono::time_point< SrcClock, Duration > &

tp

)

-> decltype(clock_cast_detail::cc_impl<DstClock>(tp, &tp))

current_zone()

DATE_API const time_zone * date::current_zone

(

)

exceptions()

os date::exceptions

(

std::ios::failbit|std::ios::badbit

)

Initial value:

{
    std::basic_ostringstream<CharT> os

floor() [1/3]

template<class To , class Rep , class Period >

CONSTCD14 std::enable_if< detail::no_overflow<Period, typename To::period>::value, To>::type date::floor ( const std::chrono::duration< Rep, Period > &  d )

inline

floor() [2/3]

template<class To , class Rep , class Period >

CONSTCD14 std::enable_if< !detail::no_overflow<Period, typename To::period>::value, To>::type date::floor ( const std::chrono::duration< Rep, Period > &  d )

inline

floor() [3/3]

template<class To , class Clock , class FromDuration >

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

inline

format() [1/4]

template<class CharT , class Streamable >

auto date::format	(	const std::locale &	loc,
		const CharT *	fmt,
		const Streamable &	tp
	)		-> decltype(to_stream(std::declval<std::basic_ostream<CharT>&>(), fmt, tp), std::basic_string<CharT>

format() [2/4]

template<class CharT , class Streamable >

auto date::format	(	const CharT *	fmt,
		const Streamable &	tp
	)		-> decltype(to_stream(std::declval<std::basic_ostream<CharT>&>(), fmt, tp), std::basic_string<CharT>

format() [3/4]

template<class CharT , class Traits , class Alloc , class Streamable >

auto date::format	(	const std::locale &	loc,
		const std::basic_string< CharT, Traits, Alloc > &	fmt,
		const Streamable &	tp
	)		-> decltype(to_stream(std::declval<std::basic_ostream<CharT, Traits>&>(), fmt.c_str(), tp), std::basic_string<CharT, Traits, Alloc>

format() [4/4]

template<class CharT , class Traits , class Alloc , class Streamable >

auto date::format	(	const std::basic_string< CharT, Traits, Alloc > &	fmt,
		const Streamable &	tp
	)		-> decltype(to_stream(std::declval<std::basic_ostream<CharT, Traits>&>(), fmt.c_str(), tp), std::basic_string<CharT, Traits, Alloc>

from_stream() [1/14]

template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		utc_time< Duration > &	tp,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [2/14]

template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		tai_time< Duration > &	tp,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [3/14]

template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		gps_time< Duration > &	tp,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [4/14]

template<class CharT , class Traits , class Duration , class Alloc >

std::basic_istream< CharT, Traits > & date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		fields< Duration > &	fds,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [5/14]

template<class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		year &	y,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [6/14]

template<class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		month &	m,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [7/14]

template<class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		day &	d,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [8/14]

template<class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		weekday &	wd,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [9/14]

template<class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		year_month &	ym,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [10/14]

template<class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		month_day &	md,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [11/14]

template<class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		year_month_day &	ymd,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [12/14]

template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		sys_time< Duration > &	tp,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [13/14]

template<class Duration , class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		local_time< Duration > &	tp,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

from_stream() [14/14]

template<class Rep , class Period , class CharT , class Traits , class Alloc = std::allocator<CharT>>

std::basic_istream<CharT, Traits>& date::from_stream	(	std::basic_istream< CharT, Traits > &	is,
		const CharT *	fmt,
		std::chrono::duration< Rep, Period > &	d,
		std::basic_string< CharT, Traits, Alloc > *	abbrev = nullptr,
		std::chrono::minutes *	offset = nullptr
	)

get_tzdb()

DATE_API const tzdb & date::get_tzdb

(

)

get_tzdb_list()

DATE_API tzdb_list & date::get_tzdb_list

(

)

imbue()

os date::imbue

(

loc

)

is_leap_second()

template<class Duration >

std::pair<bool, std::chrono::seconds> date::is_leap_second

(

date::utc_time< Duration > const &

ut

)

locate_zone()

DATE_API const time_zone * date::locate_zone

(

const std::string &

tz_name

)

make_time() [1/5]

template<class Rep , class Period , class = typename std::enable_if <!std::chrono::treat_as_floating_point<Rep>::value>::type>

CONSTCD11 time_of_day<std::chrono::duration<Rep, Period> > date::make_time ( const std::chrono::duration< Rep, Period > &  d )

inline

make_time() [2/5]

CONSTCD11 time_of_day<std::chrono::hours> date::make_time ( const std::chrono::hours &  h, unsigned  md  )

inline

make_time() [3/5]

CONSTCD11 time_of_day<std::chrono::minutes> date::make_time ( const std::chrono::hours &  h, const std::chrono::minutes &  m, unsigned  md  )

inline

make_time() [4/5]

CONSTCD11 time_of_day<std::chrono::seconds> date::make_time ( const std::chrono::hours &  h, const std::chrono::minutes &  m, const std::chrono::seconds &  s, unsigned  md  )

inline

make_time() [5/5]

template<class Rep , class Period , class = typename std::enable_if<std::ratio_less<Period, std::ratio<1>>::value>::type>

CONSTCD11 time_of_day<std::chrono::duration<Rep, Period> > date::make_time ( const std::chrono::hours &  h, const std::chrono::minutes &  m, const std::chrono::seconds &  s, const std::chrono::duration< Rep, Period > &  sub_s, unsigned  md  )

inline

make_zoned() [1/14]

zoned_time<std::chrono::seconds> date::make_zoned ( )

inline

make_zoned() [2/14]

template<class Duration >

zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::make_zoned ( const sys_time< Duration > &  tp )

inline

make_zoned() [3/14]

template<class TimeZonePtr , class = typename std::enable_if < std::is_class < typename std::decay < decltype(*detail::to_raw_pointer(std::declval<TimeZonePtr&>())) >::type >{} >::type>

zoned_time<std::chrono::seconds, TimeZonePtr> date::make_zoned ( TimeZonePtr  z )

inline

make_zoned() [4/14]

zoned_seconds date::make_zoned ( const std::string &  name )

inline

make_zoned() [5/14]

template<class Duration , class TimeZonePtr , class = typename std::enable_if < std::is_class<typename std::decay<decltype(*std::declval<TimeZonePtr&>())>::type>{} >::type>

zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type, TimeZonePtr> date::make_zoned ( TimeZonePtr  zone, const local_time< Duration > &  tp  )

inline

make_zoned() [6/14]

template<class Duration , class TimeZonePtr , class = typename std::enable_if < std::is_class<typename std::decay<decltype(*std::declval<TimeZonePtr&>())>::type>{} >::type>

zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type, TimeZonePtr> date::make_zoned ( TimeZonePtr  zone, const local_time< Duration > &  tp, choose  c  )

inline

make_zoned() [7/14]

template<class Duration >

zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::make_zoned ( const std::string &  name, const local_time< Duration > &  tp  )

inline

make_zoned() [8/14]

template<class Duration >

zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::make_zoned ( const std::string &  name, const local_time< Duration > &  tp, choose  c  )

inline

make_zoned() [9/14]

template<class Duration , class TimeZonePtr >

zoned_time<Duration, TimeZonePtr> date::make_zoned ( TimeZonePtr  zone, const zoned_time< Duration, TimeZonePtr > &  zt  )

inline

make_zoned() [10/14]

template<class Duration , class TimeZonePtr >

zoned_time<Duration, TimeZonePtr> date::make_zoned ( const std::string &  name, const zoned_time< Duration, TimeZonePtr > &  zt  )

inline

make_zoned() [11/14]

template<class Duration , class TimeZonePtr >

zoned_time<Duration, TimeZonePtr> date::make_zoned ( TimeZonePtr  zone, const zoned_time< Duration, TimeZonePtr > &  zt, choose  c  )

inline

make_zoned() [12/14]

template<class Duration , class TimeZonePtr >

zoned_time<Duration, TimeZonePtr> date::make_zoned ( const std::string &  name, const zoned_time< Duration, TimeZonePtr > &  zt, choose  c  )

inline

make_zoned() [13/14]

template<class Duration , class TimeZonePtr , class = typename std::enable_if < std::is_class<typename std::decay<decltype(*std::declval<TimeZonePtr&>())>::type>{} >::type>

zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type, TimeZonePtr> date::make_zoned ( TimeZonePtr  zone, const sys_time< Duration > &  st  )

inline

make_zoned() [14/14]

template<class Duration >

zoned_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::make_zoned ( const std::string &  name, const sys_time< Duration > &  st  )

inline

operator!=() [1/21]

CONSTCD11 bool date::operator!= ( const day &  x, const day &  y  )

inline

operator!=() [2/21]

CONSTCD11 bool date::operator!= ( const month &  x, const month &  y  )

inline

operator!=() [3/21]

CONSTCD11 bool date::operator!= ( const year &  x, const year &  y  )

inline

operator!=() [4/21]

CONSTCD11 bool date::operator!= ( const weekday &  x, const weekday &  y  )

inline

operator!=() [5/21]

CONSTCD11 bool date::operator!= ( const weekday_indexed &  x, const weekday_indexed &  y  )

inline

operator!=() [6/21]

CONSTCD11 bool date::operator!= ( const weekday_last &  x, const weekday_last &  y  )

inline

operator!=() [7/21]

CONSTCD11 bool date::operator!= ( const year_month &  x, const year_month &  y  )

inline

operator!=() [8/21]

CONSTCD11 bool date::operator!= ( const month_day &  x, const month_day &  y  )

inline

operator!=() [9/21]

CONSTCD11 bool date::operator!= ( const month_day_last &  x, const month_day_last &  y  )

inline

operator!=() [10/21]

CONSTCD11 bool date::operator!= ( const month_weekday &  x, const month_weekday &  y  )

inline

operator!=() [11/21]

CONSTCD11 bool date::operator!= ( const month_weekday_last &  x, const month_weekday_last &  y  )

inline

operator!=() [12/21]

CONSTCD11 bool date::operator!= ( const year_month_day &  x, const year_month_day &  y  )

inline

operator!=() [13/21]

CONSTCD11 bool date::operator!= ( const year_month_day_last &  x, const year_month_day_last &  y  )

inline

operator!=() [14/21]

template<class Duration1 , class Duration2 , class TimeZonePtr >

bool date::operator!= ( const zoned_time< Duration1, TimeZonePtr > &  x, const zoned_time< Duration2, TimeZonePtr > &  y  )

inline

operator!=() [15/21]

CONSTCD11 bool date::operator!= ( const year_month_weekday &  x, const year_month_weekday &  y  )

inline

operator!=() [16/21]

CONSTCD11 bool date::operator!= ( const year_month_weekday_last &  x, const year_month_weekday_last &  y  )

inline

operator!=() [17/21]

bool date::operator!= ( const time_zone &  x, const time_zone &  y  )

inline

operator!=() [18/21]

bool date::operator!= ( const link &  x, const link &  y  )

inline

operator!=() [19/21]

bool date::operator!= ( const leap &  x, const leap &  y  )

inline

operator!=() [20/21]

template<class Duration >

bool date::operator!= ( const leap &  x, const sys_time< Duration > &  y  )

inline

operator!=() [21/21]

template<class Duration >

bool date::operator!= ( const sys_time< Duration > &  x, const leap &  y  )

inline

operator+() [1/28]

CONSTCD11 day date::operator+ ( const day &  x, const days &  y  )

inline

operator+() [2/28]

CONSTCD11 day date::operator+ ( const days &  x, const day &  y  )

inline

operator+() [3/28]

CONSTCD14 month date::operator+ ( const month &  x, const months &  y  )

inline

operator+() [4/28]

CONSTCD14 month date::operator+ ( const months &  x, const month &  y  )

inline

operator+() [5/28]

CONSTCD11 year date::operator+ ( const year &  x, const years &  y  )

inline

operator+() [6/28]

CONSTCD11 year date::operator+ ( const years &  x, const year &  y  )

inline

operator+() [7/28]

CONSTCD14 weekday date::operator+ ( const weekday &  x, const days &  y  )

inline

operator+() [8/28]

CONSTCD14 weekday date::operator+ ( const days &  x, const weekday &  y  )

inline

operator+() [9/28]

CONSTCD14 year_month date::operator+ ( const year_month &  ym, const months &  dm  )

inline

operator+() [10/28]

CONSTCD14 year_month date::operator+ ( const months &  dm, const year_month &  ym  )

inline

operator+() [11/28]

CONSTCD11 year_month date::operator+ ( const year_month &  ym, const years &  dy  )

inline

operator+() [12/28]

CONSTCD11 year_month date::operator+ ( const years &  dy, const year_month &  ym  )

inline

operator+() [13/28]

CONSTCD14 year_month_day date::operator+ ( const year_month_day &  ymd, const months &  dm  )

inline

operator+() [14/28]

CONSTCD14 year_month_day date::operator+ ( const months &  dm, const year_month_day &  ymd  )

inline

operator+() [15/28]

CONSTCD11 year_month_day date::operator+ ( const year_month_day &  ymd, const years &  dy  )

inline

operator+() [16/28]

CONSTCD11 year_month_day date::operator+ ( const years &  dy, const year_month_day &  ymd  )

inline

operator+() [17/28]

CONSTCD14 year_month_day_last date::operator+ ( const year_month_day_last &  ymdl, const months &  dm  )

inline

operator+() [18/28]

CONSTCD14 year_month_day_last date::operator+ ( const months &  dm, const year_month_day_last &  ymdl  )

inline

operator+() [19/28]

CONSTCD11 year_month_day_last date::operator+ ( const year_month_day_last &  ymdl, const years &  dy  )

inline

operator+() [20/28]

CONSTCD11 year_month_day_last date::operator+ ( const years &  dy, const year_month_day_last &  ymdl  )

inline

operator+() [21/28]

CONSTCD14 year_month_weekday date::operator+ ( const year_month_weekday &  ymwd, const months &  dm  )

inline

operator+() [22/28]

CONSTCD14 year_month_weekday date::operator+ ( const months &  dm, const year_month_weekday &  ymwd  )

inline

operator+() [23/28]

CONSTCD11 year_month_weekday date::operator+ ( const year_month_weekday &  ymwd, const years &  dy  )

inline

operator+() [24/28]

CONSTCD11 year_month_weekday date::operator+ ( const years &  dy, const year_month_weekday &  ymwd  )

inline

operator+() [25/28]

CONSTCD14 year_month_weekday_last date::operator+ ( const year_month_weekday_last &  ymwdl, const months &  dm  )

inline

operator+() [26/28]

CONSTCD14 year_month_weekday_last date::operator+ ( const months &  dm, const year_month_weekday_last &  ymwdl  )

inline

operator+() [27/28]

CONSTCD11 year_month_weekday_last date::operator+ ( const year_month_weekday_last &  ymwdl, const years &  dy  )

inline

operator+() [28/28]

CONSTCD11 year_month_weekday_last date::operator+ ( const years &  dy, const year_month_weekday_last &  ymwdl  )

inline

operator-() [1/19]

CONSTCD11 day date::operator- ( const day &  x, const days &  y  )

inline

operator-() [2/19]

CONSTCD11 days date::operator- ( const day &  x, const day &  y  )

inline

operator-() [3/19]

CONSTCD14 month date::operator- ( const month &  x, const months &  y  )

inline

operator-() [4/19]

CONSTCD14 months date::operator- ( const month &  x, const month &  y  )

inline

operator-() [5/19]

CONSTCD11 year date::operator- ( const year &  x, const years &  y  )

inline

operator-() [6/19]

CONSTCD11 years date::operator- ( const year &  x, const year &  y  )

inline

operator-() [7/19]

CONSTCD14 weekday date::operator- ( const weekday &  x, const days &  y  )

inline

operator-() [8/19]

CONSTCD14 days date::operator- ( const weekday &  x, const weekday &  y  )

inline

operator-() [9/19]

CONSTCD14 year_month date::operator- ( const year_month &  ym, const months &  dm  )

inline

operator-() [10/19]

CONSTCD11 months date::operator- ( const year_month &  x, const year_month &  y  )

inline

operator-() [11/19]

CONSTCD11 year_month date::operator- ( const year_month &  ym, const years &  dy  )

inline

operator-() [12/19]

CONSTCD14 year_month_day date::operator- ( const year_month_day &  ymd, const months &  dm  )

inline

operator-() [13/19]

CONSTCD11 year_month_day date::operator- ( const year_month_day &  ymd, const years &  dy  )

inline

operator-() [14/19]

CONSTCD14 year_month_day_last date::operator- ( const year_month_day_last &  ymdl, const months &  dm  )

inline

operator-() [15/19]

CONSTCD11 year_month_day_last date::operator- ( const year_month_day_last &  ymdl, const years &  dy  )

inline

operator-() [16/19]

CONSTCD14 year_month_weekday date::operator- ( const year_month_weekday &  ymwd, const months &  dm  )

inline

operator-() [17/19]

CONSTCD11 year_month_weekday date::operator- ( const year_month_weekday &  ymwd, const years &  dy  )

inline

operator-() [18/19]

CONSTCD14 year_month_weekday_last date::operator- ( const year_month_weekday_last &  ymwdl, const months &  dm  )

inline

operator-() [19/19]

CONSTCD11 year_month_weekday_last date::operator- ( const year_month_weekday_last &  ymwdl, const years &  dy  )

inline

operator/() [1/40]

CONSTCD11 year_month date::operator/ ( const year &  y, const month &  m  )

inline

operator/() [2/40]

CONSTCD11 year_month date::operator/ ( const year &  y, int  m  )

inline

operator/() [3/40]

CONSTCD11 month_day date::operator/ ( const day &  d, const month &  m  )

inline

operator/() [4/40]

CONSTCD11 month_day date::operator/ ( const day &  d, int  m  )

inline

operator/() [5/40]

CONSTCD11 month_day date::operator/ ( const month &  m, const day &  d  )

inline

operator/() [6/40]

CONSTCD11 month_day date::operator/ ( const month &  m, int  d  )

inline

operator/() [7/40]

CONSTCD11 month_day date::operator/ ( int  m, const day &  d  )

inline

operator/() [8/40]

CONSTCD11 month_day_last date::operator/ ( const month &  m, last_spec    )

inline

operator/() [9/40]

CONSTCD11 month_day_last date::operator/ ( int  m, last_spec    )

inline

operator/() [10/40]

CONSTCD11 month_day_last date::operator/ ( last_spec  , const month &  m  )

inline

operator/() [11/40]

CONSTCD11 month_day_last date::operator/ ( last_spec  , int  m  )

inline

operator/() [12/40]

CONSTCD11 month_weekday date::operator/ ( const month &  m, const weekday_indexed &  wdi  )

inline

operator/() [13/40]

CONSTCD11 month_weekday date::operator/ ( int  m, const weekday_indexed &  wdi  )

inline

operator/() [14/40]

CONSTCD11 month_weekday date::operator/ ( const weekday_indexed &  wdi, const month &  m  )

inline

operator/() [15/40]

CONSTCD11 month_weekday date::operator/ ( const weekday_indexed &  wdi, int  m  )

inline

operator/() [16/40]

CONSTCD11 month_weekday_last date::operator/ ( const month &  m, const weekday_last &  wdl  )

inline

operator/() [17/40]

CONSTCD11 month_weekday_last date::operator/ ( int  m, const weekday_last &  wdl  )

inline

operator/() [18/40]

CONSTCD11 month_weekday_last date::operator/ ( const weekday_last &  wdl, const month &  m  )

inline

operator/() [19/40]

CONSTCD11 month_weekday_last date::operator/ ( const weekday_last &  wdl, int  m  )

inline

operator/() [20/40]

CONSTCD11 year_month_day date::operator/ ( const year_month &  ym, const day &  d  )

inline

operator/() [21/40]

CONSTCD11 year_month_day date::operator/ ( const year_month &  ym, int  d  )

inline

operator/() [22/40]

CONSTCD11 year_month_day date::operator/ ( const year &  y, const month_day &  md  )

inline

operator/() [23/40]

CONSTCD11 year_month_day date::operator/ ( int  y, const month_day &  md  )

inline

operator/() [24/40]

CONSTCD11 year_month_day date::operator/ ( const month_day &  md, const year &  y  )

inline

operator/() [25/40]

CONSTCD11 year_month_day date::operator/ ( const month_day &  md, int  y  )

inline

operator/() [26/40]

CONSTCD11 year_month_day_last date::operator/ ( const year_month &  ym, last_spec    )

inline

operator/() [27/40]

CONSTCD11 year_month_day_last date::operator/ ( const year &  y, const month_day_last &  mdl  )

inline

operator/() [28/40]

CONSTCD11 year_month_day_last date::operator/ ( int  y, const month_day_last &  mdl  )

inline

operator/() [29/40]

CONSTCD11 year_month_day_last date::operator/ ( const month_day_last &  mdl, const year &  y  )

inline

operator/() [30/40]

CONSTCD11 year_month_day_last date::operator/ ( const month_day_last &  mdl, int  y  )

inline

operator/() [31/40]

CONSTCD11 year_month_weekday date::operator/ ( const year_month &  ym, const weekday_indexed &  wdi  )

inline

operator/() [32/40]

CONSTCD11 year_month_weekday date::operator/ ( const year &  y, const month_weekday &  mwd  )

inline

operator/() [33/40]

CONSTCD11 year_month_weekday date::operator/ ( int  y, const month_weekday &  mwd  )

inline

operator/() [34/40]

CONSTCD11 year_month_weekday date::operator/ ( const month_weekday &  mwd, const year &  y  )

inline

operator/() [35/40]

CONSTCD11 year_month_weekday date::operator/ ( const month_weekday &  mwd, int  y  )

inline

operator/() [36/40]

CONSTCD11 year_month_weekday_last date::operator/ ( const year_month &  ym, const weekday_last &  wdl  )

inline

operator/() [37/40]

CONSTCD11 year_month_weekday_last date::operator/ ( const year &  y, const month_weekday_last &  mwdl  )

inline

operator/() [38/40]

CONSTCD11 year_month_weekday_last date::operator/ ( int  y, const month_weekday_last &  mwdl  )

inline

operator/() [39/40]

CONSTCD11 year_month_weekday_last date::operator/ ( const month_weekday_last &  mwdl, const year &  y  )

inline

operator/() [40/40]

CONSTCD11 year_month_weekday_last date::operator/ ( const month_weekday_last &  mwdl, int  y  )

inline

operator<() [1/9]

CONSTCD11 bool date::operator< ( const day &  x, const day &  y  )

inline

operator<() [2/9]

CONSTCD11 bool date::operator< ( const month &  x, const month &  y  )

inline

operator<() [3/9]

CONSTCD11 bool date::operator< ( const year &  x, const year &  y  )

inline

operator<() [4/9]

CONSTCD11 bool date::operator< ( const year_month &  x, const year_month &  y  )

inline

operator<() [5/9]

CONSTCD11 bool date::operator< ( const month_day &  x, const month_day &  y  )

inline

operator<() [6/9]

CONSTCD11 bool date::operator< ( const month_day_last &  x, const month_day_last &  y  )

inline

operator<() [7/9]

CONSTCD11 bool date::operator< ( const year_month_day &  x, const year_month_day &  y  )

inline

operator<() [8/9]

CONSTCD11 bool date::operator< ( const year_month_day_last &  x, const year_month_day_last &  y  )

inline

operator<() [9/9]

bool date::operator< ( const time_zone &  x, const time_zone &  y  )

inline

operator<<() [1/29]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::operator<<	(	std::basic_ostream< CharT, Traits > &	os,
		const sys_info &	r
	)

operator<<() [2/29]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::operator<<	(	std::basic_ostream< CharT, Traits > &	os,
		const local_info &	r
	)

operator<<() [3/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const day &  d  )

inline

operator<<() [4/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const month &  m  )

inline

operator<<() [5/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const year &  y  )

inline

operator<<() [6/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const weekday &  wd  )

inline

operator<<() [7/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const weekday_indexed &  wdi  )

inline

operator<<() [8/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const weekday_last &  wdl  )

inline

operator<<() [9/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const year_month &  ym  )

inline

operator<<() [10/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const month_day &  md  )

inline

operator<<() [11/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const month_day_last &  mdl  )

inline

operator<<() [12/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const month_weekday &  mwd  )

inline

operator<<() [13/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const month_weekday_last &  mwdl  )

inline

operator<<() [14/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const year_month_day &  ymd  )

inline

operator<<() [15/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const year_month_day_last &  ymdl  )

inline

operator<<() [16/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const year_month_weekday &  ymwdi  )

inline

operator<<() [17/29]

template<class CharT , class Traits >

std::basic_ostream< CharT, Traits > & date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const year_month_weekday_last &  ymwdl  )

inline

operator<<() [18/29]

template<class CharT , class Traits , class Duration , class TimeZonePtr >

std::basic_ostream<CharT, Traits>& date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const zoned_time< Duration, TimeZonePtr > &  t  )

inline

operator<<() [19/29]

template<class CharT , class Traits , class Duration >

std::basic_ostream<CharT, Traits>& date::operator<<	(	std::basic_ostream< CharT, Traits > &	os,
		const utc_time< Duration > &	t
	)

operator<<() [20/29]

template<class CharT , class Traits , class Duration >

std::basic_ostream<CharT, Traits>& date::operator<<	(	std::basic_ostream< CharT, Traits > &	os,
		const tai_time< Duration > &	t
	)

operator<<() [21/29]

template<class CharT , class Traits , class Duration >

std::basic_ostream<CharT, Traits>& date::operator<<	(	std::basic_ostream< CharT, Traits > &	os,
		const gps_time< Duration > &	t
	)

operator<<() [22/29]

std::ostream& date::operator<<	(	std::ostream &	os,
		const time_zone &	z
	)

operator<<() [23/29]

std::ostream& date::operator<<	(	std::ostream &	os,
		const leap &	x
	)

operator<<() [24/29]

std::ostream& date::operator<<	(	std::ostream &	os,
		const link &	x
	)

operator<<() [25/29]

DATE_API std::ostream & date::operator<<	(	std::ostream &	os,
		const tzdb &	db
	)

operator<<() [26/29]

template<class CharT , class Traits , class Duration >

std::enable_if< !std::chrono::treat_as_floating_point<typename Duration::rep>::value && std::ratio_less<typename Duration::period, days::period>::value , std::basic_ostream<CharT, Traits>&>::type date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const sys_time< Duration > &  tp  )

inline

operator<<() [27/29]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const sys_days &  dp  )

inline

operator<<() [28/29]

template<class CharT , class Traits , class Duration >

std::basic_ostream<CharT, Traits>& date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const local_time< Duration > &  ut  )

inline

operator<<() [29/29]

template<class CharT , class Traits , class Rep , class Period >

std::basic_ostream<CharT, Traits>& date::operator<< ( std::basic_ostream< CharT, Traits > &  os, const std::chrono::duration< Rep, Period > &  d  )

inline

operator<=() [1/13]

CONSTCD11 bool date::operator<= ( const day &  x, const day &  y  )

inline

operator<=() [2/13]

CONSTCD11 bool date::operator<= ( const month &  x, const month &  y  )

inline

operator<=() [3/13]

CONSTCD11 bool date::operator<= ( const year &  x, const year &  y  )

inline

operator<=() [4/13]

CONSTCD11 bool date::operator<= ( const year_month &  x, const year_month &  y  )

inline

operator<=() [5/13]

CONSTCD11 bool date::operator<= ( const month_day &  x, const month_day &  y  )

inline

operator<=() [6/13]

CONSTCD11 bool date::operator<= ( const month_day_last &  x, const month_day_last &  y  )

inline

operator<=() [7/13]

CONSTCD11 bool date::operator<= ( const year_month_day &  x, const year_month_day &  y  )

inline

operator<=() [8/13]

CONSTCD11 bool date::operator<= ( const year_month_day_last &  x, const year_month_day_last &  y  )

inline

operator<=() [9/13]

bool date::operator<= ( const time_zone &  x, const time_zone &  y  )

inline

operator<=() [10/13]

bool date::operator<= ( const link &  x, const link &  y  )

inline

operator<=() [11/13]

bool date::operator<= ( const leap &  x, const leap &  y  )

inline

operator<=() [12/13]

template<class Duration >

bool date::operator<= ( const leap &  x, const sys_time< Duration > &  y  )

inline

operator<=() [13/13]

template<class Duration >

bool date::operator<= ( const sys_time< Duration > &  x, const leap &  y  )

inline

operator==() [1/18]

CONSTCD11 bool date::operator== ( const day &  x, const day &  y  )

inline

operator==() [2/18]

template<class Duration1 , class Duration2 , class TimeZonePtr >

bool date::operator== ( const zoned_time< Duration1, TimeZonePtr > &  x, const zoned_time< Duration2, TimeZonePtr > &  y  )

inline

operator==() [3/18]

CONSTCD11 bool date::operator== ( const month &  x, const month &  y  )

inline

operator==() [4/18]

CONSTCD11 bool date::operator== ( const year &  x, const year &  y  )

inline

operator==() [5/18]

CONSTCD11 bool date::operator== ( const weekday &  x, const weekday &  y  )

inline

operator==() [6/18]

CONSTCD11 bool date::operator== ( const weekday_indexed &  x, const weekday_indexed &  y  )

inline

operator==() [7/18]

CONSTCD11 bool date::operator== ( const weekday_last &  x, const weekday_last &  y  )

inline

operator==() [8/18]

CONSTCD11 bool date::operator== ( const year_month &  x, const year_month &  y  )

inline

operator==() [9/18]

CONSTCD11 bool date::operator== ( const month_day &  x, const month_day &  y  )

inline

operator==() [10/18]

CONSTCD11 bool date::operator== ( const month_day_last &  x, const month_day_last &  y  )

inline

operator==() [11/18]

CONSTCD11 bool date::operator== ( const month_weekday &  x, const month_weekday &  y  )

inline

operator==() [12/18]

CONSTCD11 bool date::operator== ( const month_weekday_last &  x, const month_weekday_last &  y  )

inline

operator==() [13/18]

CONSTCD11 bool date::operator== ( const year_month_day &  x, const year_month_day &  y  )

inline

operator==() [14/18]

CONSTCD11 bool date::operator== ( const year_month_day_last &  x, const year_month_day_last &  y  )

inline

operator==() [15/18]

CONSTCD11 bool date::operator== ( const year_month_weekday &  x, const year_month_weekday &  y  )

inline

operator==() [16/18]

CONSTCD11 bool date::operator== ( const year_month_weekday_last &  x, const year_month_weekday_last &  y  )

inline

operator==() [17/18]

bool date::operator== ( const time_zone &  x, const time_zone &  y  )

inline

operator==() [18/18]

template<class Duration >

bool date::operator== ( const sys_time< Duration > &  x, const leap &  y  )

inline

operator>() [1/13]

CONSTCD11 bool date::operator> ( const day &  x, const day &  y  )

inline

operator>() [2/13]

CONSTCD11 bool date::operator> ( const month &  x, const month &  y  )

inline

operator>() [3/13]

CONSTCD11 bool date::operator> ( const year &  x, const year &  y  )

inline

operator>() [4/13]

CONSTCD11 bool date::operator> ( const year_month &  x, const year_month &  y  )

inline

operator>() [5/13]

CONSTCD11 bool date::operator> ( const month_day &  x, const month_day &  y  )

inline

operator>() [6/13]

CONSTCD11 bool date::operator> ( const month_day_last &  x, const month_day_last &  y  )

inline

operator>() [7/13]

CONSTCD11 bool date::operator> ( const year_month_day &  x, const year_month_day &  y  )

inline

operator>() [8/13]

CONSTCD11 bool date::operator> ( const year_month_day_last &  x, const year_month_day_last &  y  )

inline

operator>() [9/13]

bool date::operator> ( const time_zone &  x, const time_zone &  y  )

inline

operator>() [10/13]

bool date::operator> ( const link &  x, const link &  y  )

inline

operator>() [11/13]

bool date::operator> ( const leap &  x, const leap &  y  )

inline

operator>() [12/13]

template<class Duration >

bool date::operator> ( const leap &  x, const sys_time< Duration > &  y  )

inline

operator>() [13/13]

template<class Duration >

bool date::operator> ( const sys_time< Duration > &  x, const leap &  y  )

inline

operator>=() [1/13]

CONSTCD11 bool date::operator>= ( const day &  x, const day &  y  )

inline

operator>=() [2/13]

CONSTCD11 bool date::operator>= ( const month &  x, const month &  y  )

inline

operator>=() [3/13]

CONSTCD11 bool date::operator>= ( const year &  x, const year &  y  )

inline

operator>=() [4/13]

CONSTCD11 bool date::operator>= ( const year_month &  x, const year_month &  y  )

inline

operator>=() [5/13]

CONSTCD11 bool date::operator>= ( const month_day &  x, const month_day &  y  )

inline

operator>=() [6/13]

CONSTCD11 bool date::operator>= ( const month_day_last &  x, const month_day_last &  y  )

inline

operator>=() [7/13]

CONSTCD11 bool date::operator>= ( const year_month_day &  x, const year_month_day &  y  )

inline

operator>=() [8/13]

CONSTCD11 bool date::operator>= ( const year_month_day_last &  x, const year_month_day_last &  y  )

inline

operator>=() [9/13]

bool date::operator>= ( const time_zone &  x, const time_zone &  y  )

inline

operator>=() [10/13]

bool date::operator>= ( const link &  x, const link &  y  )

inline

operator>=() [11/13]

bool date::operator>= ( const leap &  x, const leap &  y  )

inline

operator>=() [12/13]

template<class Duration >

bool date::operator>= ( const leap &  x, const sys_time< Duration > &  y  )

inline

operator>=() [13/13]

template<class Duration >

bool date::operator>= ( const sys_time< Duration > &  x, const leap &  y  )

inline

operator>>()

template<class Parsable , class CharT , class Traits , class Alloc >

std::basic_istream<CharT, Traits>& date::operator>>	(	std::basic_istream< CharT, Traits > &	is,
		const parse_manip< Parsable, CharT, Traits, Alloc > &	x
	)

parse() [1/8]

template<class Parsable , class CharT , class Traits , class Alloc >

auto date::parse ( const std::basic_string< CharT, Traits, Alloc > &  format, Parsable &  tp  ) -> decltype(from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format.c_str(), tp), parse_manip<Parsable, CharT, Traits, Alloc>

inline

parse() [2/8]

template<class Parsable , class CharT , class Traits , class Alloc >

auto date::parse ( const std::basic_string< CharT, Traits, Alloc > &  format, Parsable &  tp, std::basic_string< CharT, Traits, Alloc > &  abbrev  ) -> decltype(from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format.c_str(), tp, &abbrev), parse_manip<Parsable, CharT, Traits, Alloc>

inline

parse() [3/8]

template<class Parsable , class CharT , class Traits , class Alloc >

auto date::parse ( const std::basic_string< CharT, Traits, Alloc > &  format, Parsable &  tp, std::chrono::minutes &  offset  ) -> decltype(from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format.c_str(), tp, nullptr, &offset), parse_manip<Parsable, CharT, Traits, Alloc>

inline

parse() [4/8]

template<class Parsable , class CharT , class Traits , class Alloc >

auto date::parse ( const std::basic_string< CharT, Traits, Alloc > &  format, Parsable &  tp, std::basic_string< CharT, Traits, Alloc > &  abbrev, std::chrono::minutes &  offset  ) -> decltype(from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format.c_str(), tp, &abbrev, &offset), parse_manip<Parsable, CharT, Traits, Alloc>

inline

parse() [5/8]

template<class Parsable , class CharT >

auto date::parse ( const CharT *  format, Parsable &  tp  ) -> decltype(from_stream(std::declval<std::basic_istream<CharT>&>(), format, tp), parse_manip<Parsable, CharT>

inline

parse() [6/8]

template<class Parsable , class CharT , class Traits , class Alloc >

auto date::parse ( const CharT *  format, Parsable &  tp, std::basic_string< CharT, Traits, Alloc > &  abbrev  ) -> decltype(from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format, tp, &abbrev), parse_manip<Parsable, CharT, Traits, Alloc>

inline

parse() [7/8]

template<class Parsable , class CharT >

auto date::parse ( const CharT *  format, Parsable &  tp, std::chrono::minutes &  offset  ) -> decltype(from_stream(std::declval<std::basic_istream<CharT>&>(), format, tp, nullptr, &offset), parse_manip<Parsable, CharT>

inline

parse() [8/8]

template<class Parsable , class CharT , class Traits , class Alloc >

auto date::parse ( const CharT *  format, Parsable &  tp, std::basic_string< CharT, Traits, Alloc > &  abbrev, std::chrono::minutes &  offset  ) -> decltype(from_stream(std::declval<std::basic_istream<CharT, Traits>&>(), format, tp, &abbrev, &offset), parse_manip<Parsable, CharT, Traits, Alloc>

inline

reload_tzdb()

DATE_API const tzdb & date::reload_tzdb

(

)

remote_download()

DATE_API bool date::remote_download

(

const std::string &

version

)

remote_install()

DATE_API bool date::remote_install

(

const std::string &

version

)

remote_version()

DATE_API std::string date::remote_version

(

)

round() [1/2]

template<class To , class Rep , class Period >

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

inline

round() [2/2]

template<class To , class Clock , class FromDuration >

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

inline

set_install()

DATE_API void date::set_install

(

const std::string &

s

)

str()

return os date::str

(

)

to_gps_time() [1/3]

template<class Duration >

gps_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_gps_time ( const sys_time< Duration > &  t )

inline

to_gps_time() [2/3]

template<class Duration >

gps_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_gps_time ( const utc_time< Duration > &  t )

inline

to_gps_time() [3/3]

template<class Duration >

gps_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_gps_time ( const tai_time< Duration > &  t )

inline

to_stream() [1/17]

template<class CharT , class Traits , class Duration , class TimeZonePtr >

std::basic_ostream<CharT, Traits>& date::to_stream	(	std::basic_ostream< CharT, Traits > &	os,
		const CharT *	fmt,
		const zoned_time< Duration, TimeZonePtr > &	tp
	)

to_stream() [2/17]

template<class CharT , class Traits , class Duration >

std::basic_ostream<CharT, Traits>& date::to_stream	(	std::basic_ostream< CharT, Traits > &	os,
		const CharT *	fmt,
		const utc_time< Duration > &	t
	)

to_stream() [3/17]

template<class CharT , class Traits , class Duration >

std::basic_ostream<CharT, Traits>& date::to_stream	(	std::basic_ostream< CharT, Traits > &	os,
		const CharT *	fmt,
		const tai_time< Duration > &	t
	)

to_stream() [4/17]

template<class CharT , class Traits , class Duration >

std::basic_ostream<CharT, Traits>& date::to_stream	(	std::basic_ostream< CharT, Traits > &	os,
		const CharT *	fmt,
		const gps_time< Duration > &	t
	)

to_stream() [5/17]

template<class CharT , class Traits , class Duration >

std::basic_ostream< CharT, Traits > & date::to_stream	(	std::basic_ostream< CharT, Traits > &	os,
		const CharT *	fmt,
		const fields< Duration > &	fds,
		const std::string *	abbrev = nullptr,
		const std::chrono::seconds *	offset_sec = nullptr
	)

to_stream() [6/17]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::to_stream ( std::basic_ostream< CharT, Traits > &  os, const CharT *  fmt, const year &  y  )

inline

to_stream() [7/17]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::to_stream ( std::basic_ostream< CharT, Traits > &  os, const CharT *  fmt, const month &  m  )

inline

to_stream() [8/17]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::to_stream ( std::basic_ostream< CharT, Traits > &  os, const CharT *  fmt, const day &  d  )

inline

to_stream() [9/17]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::to_stream ( std::basic_ostream< CharT, Traits > &  os, const CharT *  fmt, const weekday &  wd  )

inline

to_stream() [10/17]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::to_stream ( std::basic_ostream< CharT, Traits > &  os, const CharT *  fmt, const year_month &  ym  )

inline

to_stream() [11/17]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::to_stream ( std::basic_ostream< CharT, Traits > &  os, const CharT *  fmt, const month_day &  md  )

inline

to_stream() [12/17]

template<class CharT , class Traits >

std::basic_ostream<CharT, Traits>& date::to_stream ( std::basic_ostream< CharT, Traits > &  os, const CharT *  fmt, const year_month_day &  ymd  )

inline

to_stream() [13/17]

template<class CharT , class Traits , class Rep , class Period >

std::basic_ostream<CharT, Traits>& date::to_stream ( std::basic_ostream< CharT, Traits > &  os, const CharT *  fmt, const std::chrono::duration< Rep, Period > &  d  )

inline

to_stream() [14/17]

template<class CharT , class Traits , class Duration >

std::basic_ostream<CharT, Traits>& date::to_stream	(	std::basic_ostream< CharT, Traits > &	os,
		const CharT *	fmt,
		const local_time< Duration > &	tp,
		const std::string *	abbrev = nullptr,
		const std::chrono::seconds *	offset_sec = nullptr
	)

to_stream() [15/17]

template<class CharT , class Traits , class Duration >

std::basic_ostream<CharT, Traits>& date::to_stream	(	std::basic_ostream< CharT, Traits > &	os,
		const CharT *	fmt,
		const sys_time< Duration > &	tp
	)

to_stream() [16/17]

date::to_stream	(	os	,
		fmt	,
		tp
	)

to_stream() [17/17]

date::to_stream	(	os	,
		fmt.	c_str(),
		tp
	)

to_sys_time() [1/3]

template<class Duration >

sys_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_sys_time ( const utc_time< Duration > &  t )

inline

to_sys_time() [2/3]

template<class Duration >

sys_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_sys_time ( const tai_time< Duration > &  t )

inline

to_sys_time() [3/3]

template<class Duration >

sys_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_sys_time ( const gps_time< Duration > &  t )

inline

to_tai_time() [1/3]

template<class Duration >

tai_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_tai_time ( const sys_time< Duration > &  t )

inline

to_tai_time() [2/3]

template<class Duration >

tai_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_tai_time ( const utc_time< Duration > &  t )

inline

to_tai_time() [3/3]

template<class Duration >

tai_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_tai_time ( const gps_time< Duration > &  t )

inline

to_utc_time() [1/3]

template<class Duration >

utc_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_utc_time ( const sys_time< Duration > &  t )

inline

to_utc_time() [2/3]

template<class Duration >

utc_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_utc_time ( const tai_time< Duration > &  t )

inline

to_utc_time() [3/3]

template<class Duration >

utc_time<typename std::common_type<Duration, std::chrono::seconds>::type> date::to_utc_time ( const gps_time< Duration > &  t )

inline

trunc() [1/3]

template<class To , class Rep , class Period >

CONSTCD11 std::enable_if< detail::no_overflow<Period, typename To::period>::value, To>::type date::trunc ( const std::chrono::duration< Rep, Period > &  d )

inline

trunc() [2/3]

template<class To , class Rep , class Period >

CONSTCD11 std::enable_if< !detail::no_overflow<Period, typename To::period>::value, To>::type date::trunc ( const std::chrono::duration< Rep, Period > &  d )

inline

trunc() [3/3]

template<class To , class Clock , class FromDuration >

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

inline

Variable Documentation

max_day

CONSTDATA auto date::max_day = date::dec/31

max_year

CONSTDATA auto date::max_year = date::year::max()

min_day

CONSTDATA auto date::min_day = date::jan/1

min_year

CONSTDATA auto date::min_year = date::year::min()