// <chrono> -*- C++ -*-
-// Copyright (C) 2008-2016 Free Software Foundation, Inc.
+// Copyright (C) 2008-2024 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
/** @file include/chrono
* This is a Standard C++ Library header.
+ * @ingroup chrono
*/
#ifndef _GLIBCXX_CHRONO
#pragma GCC system_header
+#include <bits/requires_hosted.h> // for <ctime> and clocks
+
#if __cplusplus < 201103L
# include <bits/c++0x_warning.h>
#else
-#include <ratio>
-#include <type_traits>
-#include <limits>
-#include <ctime>
-#include <bits/parse_numbers.h> // for literals support.
+#include <bits/chrono.h>
+
+#if __cplusplus >= 202002L
+# include <bit>
+# include <sstream>
+# include <string>
+# include <vector>
+# include <bits/stl_algo.h> // upper_bound
+# include <bits/shared_ptr.h>
+# include <bits/unique_ptr.h>
+#endif
-#ifdef _GLIBCXX_USE_C99_STDINT_TR1
+#define __glibcxx_want_chrono
+#define __glibcxx_want_chrono_udls
+#include <bits/version.h>
namespace std _GLIBCXX_VISIBILITY(default)
{
+_GLIBCXX_BEGIN_NAMESPACE_VERSION
+
/**
* @defgroup chrono Time
* @ingroup utilities
*
* Classes and functions for time.
- * @{
+ *
+ * @since C++11
*/
/** @namespace std::chrono
- * @brief ISO C++ 2011 entities sub-namespace for time and date.
+ * @brief ISO C++ 2011 namespace for date and time utilities
+ * @ingroup chrono
*/
namespace chrono
{
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
+#if __cplusplus >= 202002L
+ /// @addtogroup chrono
+ /// @{
+ struct local_t { };
+ template<typename _Duration>
+ using local_time = time_point<local_t, _Duration>;
+ using local_seconds = local_time<seconds>;
+ using local_days = local_time<days>;
+
+ class utc_clock;
+ class tai_clock;
+ class gps_clock;
+
+ template<typename _Duration>
+ using utc_time = time_point<utc_clock, _Duration>;
+ using utc_seconds = utc_time<seconds>;
+
+ template<typename _Duration>
+ using tai_time = time_point<tai_clock, _Duration>;
+ using tai_seconds = tai_time<seconds>;
+
+ template<typename _Duration>
+ using gps_time = time_point<gps_clock, _Duration>;
+ using gps_seconds = gps_time<seconds>;
+
+ template<> struct is_clock<utc_clock> : true_type { };
+ template<> struct is_clock<tai_clock> : true_type { };
+ template<> struct is_clock<gps_clock> : true_type { };
+
+ template<> inline constexpr bool is_clock_v<utc_clock> = true;
+ template<> inline constexpr bool is_clock_v<tai_clock> = true;
+ template<> inline constexpr bool is_clock_v<gps_clock> = true;
+
+ struct leap_second_info
+ {
+ bool is_leap_second;
+ seconds elapsed;
+ };
- template<typename _Rep, typename _Period = ratio<1>>
- struct duration;
+ template<typename _Duration>
+ leap_second_info
+ get_leap_second_info(const utc_time<_Duration>& __ut);
- template<typename _Clock, typename _Dur = typename _Clock::duration>
- struct time_point;
+ /** A clock that measures Universal Coordinated Time (UTC).
+ *
+ * The epoch is 1970-01-01 00:00:00.
+ *
+ * @since C++20
+ */
+ class utc_clock
+ {
+ public:
+ using rep = system_clock::rep;
+ using period = system_clock::period;
+ using duration = chrono::duration<rep, period>;
+ using time_point = chrono::time_point<utc_clock>;
+ static constexpr bool is_steady = false;
- _GLIBCXX_END_NAMESPACE_VERSION
- }
+ [[nodiscard]]
+ static time_point
+ now()
+ { return from_sys(system_clock::now()); }
-_GLIBCXX_BEGIN_NAMESPACE_VERSION
+ template<typename _Duration>
+ [[nodiscard]]
+ static sys_time<common_type_t<_Duration, seconds>>
+ to_sys(const utc_time<_Duration>& __t)
+ {
+ using _CDur = common_type_t<_Duration, seconds>;
+ const auto __li = chrono::get_leap_second_info(__t);
+ sys_time<_CDur> __s{__t.time_since_epoch() - __li.elapsed};
+ if (__li.is_leap_second)
+ __s = chrono::floor<seconds>(__s) + seconds{1} - _CDur{1};
+ return __s;
+ }
- // 20.11.4.3 specialization of common_type (for duration, sfinae-friendly)
+ template<typename _Duration>
+ [[nodiscard]]
+ static utc_time<common_type_t<_Duration, seconds>>
+ from_sys(const sys_time<_Duration>& __t);
+ };
- template<typename _CT, typename _Period1, typename _Period2>
- struct __duration_common_type_wrapper
+ /** A clock that measures International Atomic Time.
+ *
+ * The epoch is 1958-01-01 00:00:00.
+ *
+ * @since C++20
+ */
+ class tai_clock
{
- private:
- typedef __static_gcd<_Period1::num, _Period2::num> __gcd_num;
- typedef __static_gcd<_Period1::den, _Period2::den> __gcd_den;
- typedef typename _CT::type __cr;
- typedef ratio<__gcd_num::value,
- (_Period1::den / __gcd_den::value) * _Period2::den> __r;
public:
- typedef __success_type<chrono::duration<__cr, __r>> type;
- };
-
- template<typename _Period1, typename _Period2>
- struct __duration_common_type_wrapper<__failure_type, _Period1, _Period2>
- { typedef __failure_type type; };
+ using rep = system_clock::rep;
+ using period = system_clock::period;
+ using duration = chrono::duration<rep, period>;
+ using time_point = chrono::time_point<tai_clock>;
+ static constexpr bool is_steady = false; // XXX true for CLOCK_TAI?
+
+ // TODO move into lib, use CLOCK_TAI on linux, add extension point.
+ [[nodiscard]]
+ static time_point
+ now()
+ { return from_utc(utc_clock::now()); }
- template<typename _Rep1, typename _Period1, typename _Rep2, typename _Period2>
- struct common_type<chrono::duration<_Rep1, _Period1>,
- chrono::duration<_Rep2, _Period2>>
- : public __duration_common_type_wrapper<typename __member_type_wrapper<
- common_type<_Rep1, _Rep2>>::type, _Period1, _Period2>::type
- { };
+ template<typename _Duration>
+ [[nodiscard]]
+ static utc_time<common_type_t<_Duration, seconds>>
+ to_utc(const tai_time<_Duration>& __t)
+ {
+ using _CDur = common_type_t<_Duration, seconds>;
+ return utc_time<_CDur>{__t.time_since_epoch()} - 378691210s;
+ }
- // 20.11.4.3 specialization of common_type (for time_point, sfinae-friendly)
+ template<typename _Duration>
+ [[nodiscard]]
+ static tai_time<common_type_t<_Duration, seconds>>
+ from_utc(const utc_time<_Duration>& __t)
+ {
+ using _CDur = common_type_t<_Duration, seconds>;
+ return tai_time<_CDur>{__t.time_since_epoch()} + 378691210s;
+ }
+ };
- template<typename _CT, typename _Clock>
- struct __timepoint_common_type_wrapper
+ /** A clock that measures GPS time.
+ *
+ * The epoch is 1980-01-06 00:00:00.
+ *
+ * @since C++20
+ */
+ class gps_clock
{
- typedef __success_type<chrono::time_point<_Clock, typename _CT::type>>
- type;
+ public:
+ using rep = system_clock::rep;
+ using period = system_clock::period;
+ using duration = chrono::duration<rep, period>;
+ using time_point = chrono::time_point<gps_clock>;
+ static constexpr bool is_steady = false; // XXX
+
+ // TODO move into lib, add extension point.
+ [[nodiscard]]
+ static time_point
+ now()
+ { return from_utc(utc_clock::now()); }
+
+ template<typename _Duration>
+ [[nodiscard]]
+ static utc_time<common_type_t<_Duration, seconds>>
+ to_utc(const gps_time<_Duration>& __t)
+ {
+ using _CDur = common_type_t<_Duration, seconds>;
+ return utc_time<_CDur>{__t.time_since_epoch()} + 315964809s;
+ }
+
+ template<typename _Duration>
+ [[nodiscard]]
+ static gps_time<common_type_t<_Duration, seconds>>
+ from_utc(const utc_time<_Duration>& __t)
+ {
+ using _CDur = common_type_t<_Duration, seconds>;
+ return gps_time<_CDur>{__t.time_since_epoch()} - 315964809s;
+ }
};
- template<typename _Clock>
- struct __timepoint_common_type_wrapper<__failure_type, _Clock>
- { typedef __failure_type type; };
- template<typename _Clock, typename _Duration1, typename _Duration2>
- struct common_type<chrono::time_point<_Clock, _Duration1>,
- chrono::time_point<_Clock, _Duration2>>
- : public __timepoint_common_type_wrapper<typename __member_type_wrapper<
- common_type<_Duration1, _Duration2>>::type, _Clock>::type
- { };
+ template<typename _DestClock, typename _SourceClock>
+ struct clock_time_conversion
+ { };
-_GLIBCXX_END_NAMESPACE_VERSION
+ // Identity conversions
- namespace chrono
- {
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ template<typename _Clock>
+ struct clock_time_conversion<_Clock, _Clock>
+ {
+ template<typename _Duration>
+ time_point<_Clock, _Duration>
+ operator()(const time_point<_Clock, _Duration>& __t) const
+ { return __t; }
+ };
- // Primary template for duration_cast impl.
- template<typename _ToDur, typename _CF, typename _CR,
- bool _NumIsOne = false, bool _DenIsOne = false>
- struct __duration_cast_impl
+ template<>
+ struct clock_time_conversion<system_clock, system_clock>
{
- template<typename _Rep, typename _Period>
- static constexpr _ToDur
- __cast(const duration<_Rep, _Period>& __d)
+ template<typename _Duration>
+ sys_time<_Duration>
+ operator()(const sys_time<_Duration>& __t) const
+ { return __t; }
+ };
+
+ template<>
+ struct clock_time_conversion<utc_clock, utc_clock>
+ {
+ template<typename _Duration>
+ utc_time<_Duration>
+ operator()(const utc_time<_Duration>& __t) const
+ { return __t; }
+ };
+
+ // Conversions between system_clock and utc_clock
+
+ template<>
+ struct clock_time_conversion<utc_clock, system_clock>
+ {
+ template<typename _Duration>
+ utc_time<common_type_t<_Duration, seconds>>
+ operator()(const sys_time<_Duration>& __t) const
+ { return utc_clock::from_sys(__t); }
+ };
+
+ template<>
+ struct clock_time_conversion<system_clock, utc_clock>
+ {
+ template<typename _Duration>
+ sys_time<common_type_t<_Duration, seconds>>
+ operator()(const utc_time<_Duration>& __t) const
+ { return utc_clock::to_sys(__t); }
+ };
+
+ template<typename _Tp, typename _Clock>
+ inline constexpr bool __is_time_point_for_v = false;
+
+ template<typename _Clock, typename _Duration>
+ inline constexpr bool
+ __is_time_point_for_v<time_point<_Clock, _Duration>, _Clock> = true;
+
+ // Conversions between system_clock and other clocks
+
+ template<typename _SourceClock>
+ struct clock_time_conversion<system_clock, _SourceClock>
+ {
+ template<typename _Duration, typename _Src = _SourceClock>
+ auto
+ operator()(const time_point<_SourceClock, _Duration>& __t) const
+ -> decltype(_Src::to_sys(__t))
{
- typedef typename _ToDur::rep __to_rep;
- return _ToDur(static_cast<__to_rep>(static_cast<_CR>(__d.count())
- * static_cast<_CR>(_CF::num)
- / static_cast<_CR>(_CF::den)));
+ using _Ret = decltype(_SourceClock::to_sys(__t));
+ static_assert(__is_time_point_for_v<_Ret, system_clock>);
+ return _SourceClock::to_sys(__t);
}
};
- template<typename _ToDur, typename _CF, typename _CR>
- struct __duration_cast_impl<_ToDur, _CF, _CR, true, true>
+ template<typename _DestClock>
+ struct clock_time_conversion<_DestClock, system_clock>
{
- template<typename _Rep, typename _Period>
- static constexpr _ToDur
- __cast(const duration<_Rep, _Period>& __d)
+ template<typename _Duration, typename _Dest = _DestClock>
+ auto
+ operator()(const sys_time<_Duration>& __t) const
+ -> decltype(_Dest::from_sys(__t))
{
- typedef typename _ToDur::rep __to_rep;
- return _ToDur(static_cast<__to_rep>(__d.count()));
+ using _Ret = decltype(_DestClock::from_sys(__t));
+ static_assert(__is_time_point_for_v<_Ret, _DestClock>);
+ return _DestClock::from_sys(__t);
}
};
- template<typename _ToDur, typename _CF, typename _CR>
- struct __duration_cast_impl<_ToDur, _CF, _CR, true, false>
+ // Conversions between utc_clock and other clocks
+
+ template<typename _SourceClock>
+ struct clock_time_conversion<utc_clock, _SourceClock>
{
- template<typename _Rep, typename _Period>
- static constexpr _ToDur
- __cast(const duration<_Rep, _Period>& __d)
+ template<typename _Duration, typename _Src = _SourceClock>
+ auto
+ operator()(const time_point<_SourceClock, _Duration>& __t) const
+ -> decltype(_Src::to_utc(__t))
{
- typedef typename _ToDur::rep __to_rep;
- return _ToDur(static_cast<__to_rep>(
- static_cast<_CR>(__d.count()) / static_cast<_CR>(_CF::den)));
+ using _Ret = decltype(_SourceClock::to_utc(__t));
+ static_assert(__is_time_point_for_v<_Ret, utc_clock>);
+ return _SourceClock::to_utc(__t);
}
};
- template<typename _ToDur, typename _CF, typename _CR>
- struct __duration_cast_impl<_ToDur, _CF, _CR, false, true>
+ template<typename _DestClock>
+ struct clock_time_conversion<_DestClock, utc_clock>
{
- template<typename _Rep, typename _Period>
- static constexpr _ToDur
- __cast(const duration<_Rep, _Period>& __d)
+ template<typename _Duration, typename _Dest = _DestClock>
+ auto
+ operator()(const utc_time<_Duration>& __t) const
+ -> decltype(_Dest::from_utc(__t))
{
- typedef typename _ToDur::rep __to_rep;
- return _ToDur(static_cast<__to_rep>(
- static_cast<_CR>(__d.count()) * static_cast<_CR>(_CF::num)));
+ using _Ret = decltype(_DestClock::from_utc(__t));
+ static_assert(__is_time_point_for_v<_Ret, _DestClock>);
+ return _DestClock::from_utc(__t);
}
};
- template<typename _Tp>
- struct __is_duration
- : std::false_type
- { };
+ /// @cond undocumented
+ namespace __detail
+ {
+ template<typename _DestClock, typename _SourceClock, typename _Duration>
+ concept __clock_convs
+ = requires (const time_point<_SourceClock, _Duration>& __t) {
+ clock_time_conversion<_DestClock, _SourceClock>{}(__t);
+ };
+
+ template<typename _DestClock, typename _SourceClock, typename _Duration>
+ concept __clock_convs_sys
+ = requires (const time_point<_SourceClock, _Duration>& __t) {
+ clock_time_conversion<_DestClock, system_clock>{}(
+ clock_time_conversion<system_clock, _SourceClock>{}(__t));
+ };
+
+ template<typename _DestClock, typename _SourceClock, typename _Duration>
+ concept __clock_convs_utc
+ = requires (const time_point<_SourceClock, _Duration>& __t) {
+ clock_time_conversion<_DestClock, utc_clock>{}(
+ clock_time_conversion<utc_clock, _SourceClock>{}(__t));
+ };
+
+ template<typename _DestClock, typename _SourceClock, typename _Duration>
+ concept __clock_convs_sys_utc
+ = requires (const time_point<_SourceClock, _Duration>& __t) {
+ clock_time_conversion<_DestClock, utc_clock>{}(
+ clock_time_conversion<utc_clock, system_clock>{}(
+ clock_time_conversion<system_clock, _SourceClock>{}(__t)));
+ };
+
+ template<typename _DestClock, typename _SourceClock, typename _Duration>
+ concept __clock_convs_utc_sys
+ = requires (const time_point<_SourceClock, _Duration>& __t) {
+ clock_time_conversion<_DestClock, system_clock>{}(
+ clock_time_conversion<system_clock, utc_clock>{}(
+ clock_time_conversion<utc_clock, _SourceClock>{}(__t)));
+ };
+
+ } // namespace __detail
+ /// @endcond
+
+ /// Convert a time point to a different clock.
+ template<typename _DestClock, typename _SourceClock, typename _Duration>
+ [[nodiscard]]
+ inline auto
+ clock_cast(const time_point<_SourceClock, _Duration>& __t)
+ requires __detail::__clock_convs<_DestClock, _SourceClock, _Duration>
+ || __detail::__clock_convs_sys<_DestClock, _SourceClock, _Duration>
+ || __detail::__clock_convs_utc<_DestClock, _SourceClock, _Duration>
+ || __detail::__clock_convs_sys_utc<_DestClock, _SourceClock, _Duration>
+ || __detail::__clock_convs_utc_sys<_DestClock, _SourceClock, _Duration>
+ {
+ constexpr bool __direct
+ = __detail::__clock_convs<_DestClock, _SourceClock, _Duration>;
+ if constexpr (__direct)
+ {
+ return clock_time_conversion<_DestClock, _SourceClock>{}(__t);
+ }
+ else
+ {
+ constexpr bool __convert_via_sys_clock
+ = __detail::__clock_convs_sys<_DestClock, _SourceClock, _Duration>;
+ constexpr bool __convert_via_utc_clock
+ = __detail::__clock_convs_utc<_DestClock, _SourceClock, _Duration>;
+ if constexpr (__convert_via_sys_clock)
+ {
+ static_assert(!__convert_via_utc_clock,
+ "clock_cast requires a unique best conversion, but "
+ "conversion is possible via system_clock and also via"
+ "utc_clock");
+ return clock_time_conversion<_DestClock, system_clock>{}(
+ clock_time_conversion<system_clock, _SourceClock>{}(__t));
+ }
+ else if constexpr (__convert_via_utc_clock)
+ {
+ return clock_time_conversion<_DestClock, utc_clock>{}(
+ clock_time_conversion<utc_clock, _SourceClock>{}(__t));
+ }
+ else
+ {
+ constexpr bool __convert_via_sys_and_utc_clocks
+ = __detail::__clock_convs_sys_utc<_DestClock,
+ _SourceClock,
+ _Duration>;
+
+ if constexpr (__convert_via_sys_and_utc_clocks)
+ {
+ constexpr bool __convert_via_utc_and_sys_clocks
+ = __detail::__clock_convs_utc_sys<_DestClock,
+ _SourceClock,
+ _Duration>;
+ static_assert(!__convert_via_utc_and_sys_clocks,
+ "clock_cast requires a unique best conversion, but "
+ "conversion is possible via system_clock followed by "
+ "utc_clock, and also via utc_clock followed by "
+ "system_clock");
+ return clock_time_conversion<_DestClock, utc_clock>{}(
+ clock_time_conversion<utc_clock, system_clock>{}(
+ clock_time_conversion<system_clock, _SourceClock>{}(__t)));
+ }
+ else
+ {
+ return clock_time_conversion<_DestClock, system_clock>{}(
+ clock_time_conversion<system_clock, utc_clock>{}(
+ clock_time_conversion<utc_clock, _SourceClock>{}(__t)));
+ }
+ }
+ }
+ }
- template<typename _Rep, typename _Period>
- struct __is_duration<duration<_Rep, _Period>>
- : std::true_type
- { };
+ // CALENDRICAL TYPES
+
+ // CLASS DECLARATIONS
+ 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;
+
+ struct last_spec
+ {
+ explicit last_spec() = default;
- /// duration_cast
- template<typename _ToDur, typename _Rep, typename _Period>
- constexpr typename enable_if<__is_duration<_ToDur>::value,
- _ToDur>::type
- duration_cast(const duration<_Rep, _Period>& __d)
- {
- typedef typename _ToDur::period __to_period;
- typedef typename _ToDur::rep __to_rep;
- typedef ratio_divide<_Period, __to_period> __cf;
- typedef typename common_type<__to_rep, _Rep, intmax_t>::type
- __cr;
- typedef __duration_cast_impl<_ToDur, __cf, __cr,
- __cf::num == 1, __cf::den == 1> __dc;
- return __dc::__cast(__d);
- }
-
- /// treat_as_floating_point
- template<typename _Rep>
- struct treat_as_floating_point
- : is_floating_point<_Rep>
- { };
+ friend constexpr month_day_last
+ operator/(int __m, last_spec) noexcept;
-#if __cplusplus > 201402L
- template <typename _Rep>
- constexpr bool treat_as_floating_point_v =
- treat_as_floating_point<_Rep>::value;
-#endif // C++17
+ friend constexpr month_day_last
+ operator/(last_spec, int __m) noexcept;
+ };
-#if __cplusplus > 201402L
-# define __cpp_lib_chrono 201510
+ inline constexpr last_spec last{};
- template<typename _ToDur, typename _Rep, typename _Period>
- constexpr enable_if_t<__is_duration<_ToDur>::value, _ToDur>
- floor(const duration<_Rep, _Period>& __d)
+ namespace __detail
+ {
+ // Compute the remainder of the Euclidean division of __n divided by __d.
+ // Euclidean division truncates toward negative infinity and always
+ // produces a remainder in the range of [0,__d-1] (whereas standard
+ // division truncates toward zero and yields a nonpositive remainder
+ // for negative __n).
+ constexpr unsigned
+ __modulo(long long __n, unsigned __d)
{
- auto __to = chrono::duration_cast<_ToDur>(__d);
- if (__to > __d)
- --__to;
- return __to;
+ if (__n >= 0)
+ return __n % __d;
+ else
+ return (__d + (__n % __d)) % __d;
}
- template<typename _ToDur, typename _Rep, typename _Period>
- constexpr enable_if_t<__is_duration<_ToDur>::value, _ToDur>
- ceil(const duration<_Rep, _Period>& __d)
+ inline constexpr unsigned __days_per_month[12]
+ = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+ }
+
+ // DAY
+
+ class day
+ {
+ private:
+ unsigned char _M_d;
+
+ public:
+ day() = default;
+
+ explicit constexpr
+ day(unsigned __d) noexcept
+ : _M_d(__d)
+ { }
+
+ constexpr day&
+ operator++() noexcept
{
- auto __to = chrono::duration_cast<_ToDur>(__d);
- if (__to < __d)
- return __to + _ToDur{1};
- return __to;
+ ++_M_d;
+ return *this;
}
- template <typename _ToDur, typename _Rep, typename _Period>
- constexpr enable_if_t<
- __and_<__is_duration<_ToDur>,
- __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
- _ToDur>
- round(const duration<_Rep, _Period>& __d)
+ constexpr day
+ operator++(int) noexcept
{
- _ToDur __t0 = chrono::floor<_ToDur>(__d);
- _ToDur __t1 = __t0 + _ToDur{1};
- auto __diff0 = __d - __t0;
- auto __diff1 = __t1 - __d;
- if (__diff0 == __diff1)
- {
- if (__t0.count() & 1)
- return __t1;
- return __t0;
- }
- else if (__diff0 < __diff1)
- return __t0;
- return __t1;
+ auto __ret = *this;
+ ++(*this);
+ return __ret;
}
- template<typename _Rep, typename _Period>
- constexpr
- enable_if_t<numeric_limits<_Rep>::is_signed, duration<_Rep, _Period>>
- abs(duration<_Rep, _Period> __d)
+ constexpr day&
+ operator--() noexcept
{
- if (__d >= __d.zero())
- return __d;
- return -__d;
+ --_M_d;
+ return *this;
}
-#endif // C++17
- /// duration_values
- template<typename _Rep>
- struct duration_values
+ constexpr day
+ operator--(int) noexcept
{
- static constexpr _Rep
- zero()
- { return _Rep(0); }
+ auto __ret = *this;
+ --(*this);
+ return __ret;
+ }
- static constexpr _Rep
- max()
- { return numeric_limits<_Rep>::max(); }
+ constexpr day&
+ operator+=(const days& __d) noexcept
+ {
+ *this = *this + __d;
+ return *this;
+ }
- static constexpr _Rep
- min()
- { return numeric_limits<_Rep>::lowest(); }
- };
+ constexpr day&
+ operator-=(const days& __d) noexcept
+ {
+ *this = *this - __d;
+ return *this;
+ }
- template<typename _Tp>
- struct __is_ratio
- : std::false_type
- { };
+ constexpr explicit
+ operator unsigned() const noexcept
+ { return _M_d; }
- template<intmax_t _Num, intmax_t _Den>
- struct __is_ratio<ratio<_Num, _Den>>
- : std::true_type
- { };
+ constexpr bool
+ ok() const noexcept
+ { return 1 <= _M_d && _M_d <= 31; }
- /// duration
- template<typename _Rep, typename _Period>
- struct duration
- {
- typedef _Rep rep;
- typedef _Period period;
-
- static_assert(!__is_duration<_Rep>::value, "rep cannot be a duration");
- static_assert(__is_ratio<_Period>::value,
- "period must be a specialization of ratio");
- static_assert(_Period::num > 0, "period must be positive");
-
- // 20.11.5.1 construction / copy / destroy
- constexpr duration() = default;
-
- // NB: Make constexpr implicit. This cannot be explicitly
- // constexpr, as any UDT that is not a literal type with a
- // constexpr copy constructor will be ill-formed.
- duration(const duration&) = default;
-
- template<typename _Rep2, typename = typename
- enable_if<is_convertible<_Rep2, rep>::value
- && (treat_as_floating_point<rep>::value
- || !treat_as_floating_point<_Rep2>::value)>::type>
- constexpr explicit duration(const _Rep2& __rep)
- : __r(static_cast<rep>(__rep)) { }
-
- template<typename _Rep2, typename _Period2, typename = typename
- enable_if<treat_as_floating_point<rep>::value
- || (ratio_divide<_Period2, period>::den == 1
- && !treat_as_floating_point<_Rep2>::value)>::type>
- constexpr duration(const duration<_Rep2, _Period2>& __d)
- : __r(duration_cast<duration>(__d).count()) { }
-
- ~duration() = default;
- duration& operator=(const duration&) = default;
-
- // 20.11.5.2 observer
- constexpr rep
- count() const
- { return __r; }
-
- // 20.11.5.3 arithmetic
- constexpr duration
- operator+() const
- { return *this; }
-
- constexpr duration
- operator-() const
- { return duration(-__r); }
-
- duration&
- operator++()
- {
- ++__r;
- return *this;
- }
+ friend constexpr bool
+ operator==(const day& __x, const day& __y) noexcept
+ { return unsigned{__x} == unsigned{__y}; }
- duration
- operator++(int)
- { return duration(__r++); }
+ friend constexpr strong_ordering
+ operator<=>(const day& __x, const day& __y) noexcept
+ { return unsigned{__x} <=> unsigned{__y}; }
- duration&
- operator--()
- {
- --__r;
- return *this;
- }
+ friend constexpr day
+ operator+(const day& __x, const days& __y) noexcept
+ { return day(unsigned{__x} + __y.count()); }
- duration
- operator--(int)
- { return duration(__r--); }
+ friend constexpr day
+ operator+(const days& __x, const day& __y) noexcept
+ { return __y + __x; }
- duration&
- operator+=(const duration& __d)
- {
- __r += __d.count();
- return *this;
- }
+ friend constexpr day
+ operator-(const day& __x, const days& __y) noexcept
+ { return __x + -__y; }
- duration&
- operator-=(const duration& __d)
- {
- __r -= __d.count();
- return *this;
- }
+ friend constexpr days
+ operator-(const day& __x, const day& __y) noexcept
+ { return days{int(unsigned{__x}) - int(unsigned{__y})}; }
- duration&
- operator*=(const rep& __rhs)
- {
- __r *= __rhs;
- return *this;
- }
+ friend constexpr month_day
+ operator/(const month& __m, const day& __d) noexcept;
- duration&
- operator/=(const rep& __rhs)
- {
- __r /= __rhs;
- return *this;
- }
+ friend constexpr month_day
+ operator/(int __m, const day& __d) noexcept;
- // DR 934.
- template<typename _Rep2 = rep>
- typename enable_if<!treat_as_floating_point<_Rep2>::value,
- duration&>::type
- operator%=(const rep& __rhs)
- {
- __r %= __rhs;
- return *this;
- }
+ friend constexpr month_day
+ operator/(const day& __d, const month& __m) noexcept;
- template<typename _Rep2 = rep>
- typename enable_if<!treat_as_floating_point<_Rep2>::value,
- duration&>::type
- operator%=(const duration& __d)
- {
- __r %= __d.count();
- return *this;
- }
+ friend constexpr month_day
+ operator/(const day& __d, int __m) noexcept;
- // 20.11.5.4 special values
- static constexpr duration
- zero()
- { return duration(duration_values<rep>::zero()); }
+ friend constexpr year_month_day
+ operator/(const year_month& __ym, const day& __d) noexcept;
+ };
- static constexpr duration
- min()
- { return duration(duration_values<rep>::min()); }
+ // MONTH
- static constexpr duration
- max()
- { return duration(duration_values<rep>::max()); }
+ class month
+ {
+ private:
+ unsigned char _M_m;
- private:
- rep __r;
- };
+ public:
+ month() = default;
+
+ explicit constexpr
+ month(unsigned __m) noexcept
+ : _M_m(__m)
+ { }
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
- constexpr typename common_type<duration<_Rep1, _Period1>,
- duration<_Rep2, _Period2>>::type
- operator+(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
+ constexpr month&
+ operator++() noexcept
{
- typedef duration<_Rep1, _Period1> __dur1;
- typedef duration<_Rep2, _Period2> __dur2;
- typedef typename common_type<__dur1,__dur2>::type __cd;
- return __cd(__cd(__lhs).count() + __cd(__rhs).count());
+ *this += months{1};
+ return *this;
}
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
- constexpr typename common_type<duration<_Rep1, _Period1>,
- duration<_Rep2, _Period2>>::type
- operator-(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
+ constexpr month
+ operator++(int) noexcept
{
- typedef duration<_Rep1, _Period1> __dur1;
- typedef duration<_Rep2, _Period2> __dur2;
- typedef typename common_type<__dur1,__dur2>::type __cd;
- return __cd(__cd(__lhs).count() - __cd(__rhs).count());
+ auto __ret = *this;
+ ++(*this);
+ return __ret;
}
- template<typename _Rep1, typename _Rep2, bool =
- is_convertible<_Rep2,
- typename common_type<_Rep1, _Rep2>::type>::value>
- struct __common_rep_type { };
+ constexpr month&
+ operator--() noexcept
+ {
+ *this -= months{1};
+ return *this;
+ }
- template<typename _Rep1, typename _Rep2>
- struct __common_rep_type<_Rep1, _Rep2, true>
- { typedef typename common_type<_Rep1, _Rep2>::type type; };
+ constexpr month
+ operator--(int) noexcept
+ {
+ auto __ret = *this;
+ --(*this);
+ return __ret;
+ }
- template<typename _Rep1, typename _Period, typename _Rep2>
- constexpr
- duration<typename __common_rep_type<_Rep1, _Rep2>::type, _Period>
- operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+ constexpr month&
+ operator+=(const months& __m) noexcept
{
- typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
- __cd;
- return __cd(__cd(__d).count() * __s);
+ *this = *this + __m;
+ return *this;
}
- template<typename _Rep1, typename _Rep2, typename _Period>
- constexpr
- duration<typename __common_rep_type<_Rep2, _Rep1>::type, _Period>
- operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d)
- { return __d * __s; }
+ constexpr month&
+ operator-=(const months& __m) noexcept
+ {
+ *this = *this - __m;
+ return *this;
+ }
+
+ explicit constexpr
+ operator unsigned() const noexcept
+ { return _M_m; }
+
+ constexpr bool
+ ok() const noexcept
+ { return 1 <= _M_m && _M_m <= 12; }
+
+ friend constexpr bool
+ operator==(const month& __x, const month& __y) noexcept
+ { return unsigned{__x} == unsigned{__y}; }
- template<typename _Rep1, typename _Period, typename _Rep2>
- constexpr duration<typename __common_rep_type<_Rep1, typename
- enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
- operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+ friend constexpr strong_ordering
+ operator<=>(const month& __x, const month& __y) noexcept
+ { return unsigned{__x} <=> unsigned{__y}; }
+
+ friend constexpr month
+ operator+(const month& __x, const months& __y) noexcept
{
- typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
- __cd;
- return __cd(__cd(__d).count() / __s);
+ auto __n = static_cast<long long>(unsigned{__x}) + (__y.count() - 1);
+ return month{__detail::__modulo(__n, 12) + 1};
}
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
- constexpr typename common_type<_Rep1, _Rep2>::type
- operator/(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
+ friend constexpr month
+ operator+(const months& __x, const month& __y) noexcept
+ { return __y + __x; }
+
+ friend constexpr month
+ operator-(const month& __x, const months& __y) noexcept
+ { return __x + -__y; }
+
+ friend constexpr months
+ operator-(const month& __x, const month& __y) noexcept
{
- typedef duration<_Rep1, _Period1> __dur1;
- typedef duration<_Rep2, _Period2> __dur2;
- typedef typename common_type<__dur1,__dur2>::type __cd;
- return __cd(__lhs).count() / __cd(__rhs).count();
+ const auto __dm = int(unsigned(__x)) - int(unsigned(__y));
+ return months{__dm < 0 ? 12 + __dm : __dm};
}
- // DR 934.
- template<typename _Rep1, typename _Period, typename _Rep2>
- constexpr duration<typename __common_rep_type<_Rep1, typename
- enable_if<!__is_duration<_Rep2>::value, _Rep2>::type>::type, _Period>
- operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s)
+ friend constexpr year_month
+ operator/(const year& __y, const month& __m) noexcept;
+
+ friend constexpr month_day
+ operator/(const month& __m, int __d) noexcept;
+
+ friend constexpr month_day_last
+ operator/(const month& __m, last_spec) noexcept;
+
+ friend constexpr month_day_last
+ operator/(last_spec, const month& __m) noexcept;
+
+ friend constexpr month_weekday
+ operator/(const month& __m, const weekday_indexed& __wdi) noexcept;
+
+ friend constexpr month_weekday
+ operator/(const weekday_indexed& __wdi, const month& __m) noexcept;
+
+ friend constexpr month_weekday_last
+ operator/(const month& __m, const weekday_last& __wdl) noexcept;
+
+ friend constexpr month_weekday_last
+ operator/(const weekday_last& __wdl, const month& __m) noexcept;
+ };
+
+ inline constexpr month January{1};
+ inline constexpr month February{2};
+ inline constexpr month March{3};
+ inline constexpr month April{4};
+ inline constexpr month May{5};
+ inline constexpr month June{6};
+ inline constexpr month July{7};
+ inline constexpr month August{8};
+ inline constexpr month September{9};
+ inline constexpr month October{10};
+ inline constexpr month November{11};
+ inline constexpr month December{12};
+
+ // YEAR
+
+ class year
+ {
+ private:
+ short _M_y;
+
+ public:
+ year() = default;
+
+ explicit constexpr
+ year(int __y) noexcept
+ : _M_y{static_cast<short>(__y)}
+ { }
+
+ static constexpr year
+ min() noexcept
+ { return year{-32767}; }
+
+ static constexpr year
+ max() noexcept
+ { return year{32767}; }
+
+ constexpr year&
+ operator++() noexcept
{
- typedef duration<typename common_type<_Rep1, _Rep2>::type, _Period>
- __cd;
- return __cd(__cd(__d).count() % __s);
+ ++_M_y;
+ return *this;
}
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
- constexpr typename common_type<duration<_Rep1, _Period1>,
- duration<_Rep2, _Period2>>::type
- operator%(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
+ constexpr year
+ operator++(int) noexcept
{
- typedef duration<_Rep1, _Period1> __dur1;
- typedef duration<_Rep2, _Period2> __dur2;
- typedef typename common_type<__dur1,__dur2>::type __cd;
- return __cd(__cd(__lhs).count() % __cd(__rhs).count());
+ auto __ret = *this;
+ ++(*this);
+ return __ret;
}
- // comparisons
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
- constexpr bool
- operator==(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
+ constexpr year&
+ operator--() noexcept
{
- typedef duration<_Rep1, _Period1> __dur1;
- typedef duration<_Rep2, _Period2> __dur2;
- typedef typename common_type<__dur1,__dur2>::type __ct;
- return __ct(__lhs).count() == __ct(__rhs).count();
+ --_M_y;
+ return *this;
}
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
- constexpr bool
- operator<(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
+ constexpr year
+ operator--(int) noexcept
{
- typedef duration<_Rep1, _Period1> __dur1;
- typedef duration<_Rep2, _Period2> __dur2;
- typedef typename common_type<__dur1,__dur2>::type __ct;
- return __ct(__lhs).count() < __ct(__rhs).count();
+ auto __ret = *this;
+ --(*this);
+ return __ret;
}
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
- constexpr bool
- operator!=(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
- { return !(__lhs == __rhs); }
+ constexpr year&
+ operator+=(const years& __y) noexcept
+ {
+ *this = *this + __y;
+ return *this;
+ }
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
- constexpr bool
- operator<=(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
- { return !(__rhs < __lhs); }
+ constexpr year&
+ operator-=(const years& __y) noexcept
+ {
+ *this = *this - __y;
+ return *this;
+ }
+
+ constexpr year
+ operator+() const noexcept
+ { return *this; }
+
+ constexpr year
+ operator-() const noexcept
+ { return year{-_M_y}; }
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
constexpr bool
- operator>(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
- { return __rhs < __lhs; }
+ is_leap() const noexcept
+ {
+ // Testing divisibility by 100 first gives better performance [1], i.e.,
+ // return _M_y % 100 == 0 ? _M_y % 400 == 0 : _M_y % 16 == 0;
+ // Furthermore, if _M_y % 100 == 0, then _M_y % 400 == 0 is equivalent
+ // to _M_y % 16 == 0, so we can simplify it to
+ // return _M_y % 100 == 0 ? _M_y % 16 == 0 : _M_y % 4 == 0. // #1
+ // Similarly, we can replace 100 with 25 (which is good since
+ // _M_y % 25 == 0 requires one fewer instruction than _M_y % 100 == 0
+ // [2]):
+ // return _M_y % 25 == 0 ? _M_y % 16 == 0 : _M_y % 4 == 0. // #2
+ // Indeed, first assume _M_y % 4 != 0. Then _M_y % 16 != 0 and hence,
+ // _M_y % 4 == 0 and _M_y % 16 == 0 are both false. Therefore, #2
+ // returns false as it should (regardless of _M_y % 25.) Now assume
+ // _M_y % 4 == 0. In this case, _M_y % 25 == 0 if, and only if,
+ // _M_y % 100 == 0, that is, #1 and #2 are equivalent. Finally, #2 is
+ // equivalent to
+ // return (_M_y & (_M_y % 25 == 0 ? 15 : 3)) == 0.
+
+ // References:
+ // [1] https://github.com/cassioneri/calendar
+ // [2] https://godbolt.org/z/55G8rn77e
+ // [3] https://gcc.gnu.org/pipermail/libstdc++/2021-June/052815.html
+
+ return (_M_y & (_M_y % 25 == 0 ? 15 : 3)) == 0;
+ }
+
+ explicit constexpr
+ operator int() const noexcept
+ { return _M_y; }
- template<typename _Rep1, typename _Period1,
- typename _Rep2, typename _Period2>
constexpr bool
- operator>=(const duration<_Rep1, _Period1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
- { return !(__lhs < __rhs); }
+ ok() const noexcept
+ { return min()._M_y <= _M_y && _M_y <= max()._M_y; }
- /// nanoseconds
- typedef duration<int64_t, nano> nanoseconds;
+ friend constexpr bool
+ operator==(const year& __x, const year& __y) noexcept
+ { return int{__x} == int{__y}; }
- /// microseconds
- typedef duration<int64_t, micro> microseconds;
+ friend constexpr strong_ordering
+ operator<=>(const year& __x, const year& __y) noexcept
+ { return int{__x} <=> int{__y}; }
- /// milliseconds
- typedef duration<int64_t, milli> milliseconds;
+ friend constexpr year
+ operator+(const year& __x, const years& __y) noexcept
+ { return year{int{__x} + static_cast<int>(__y.count())}; }
- /// seconds
- typedef duration<int64_t> seconds;
+ friend constexpr year
+ operator+(const years& __x, const year& __y) noexcept
+ { return __y + __x; }
- /// minutes
- typedef duration<int64_t, ratio< 60>> minutes;
+ friend constexpr year
+ operator-(const year& __x, const years& __y) noexcept
+ { return __x + -__y; }
- /// hours
- typedef duration<int64_t, ratio<3600>> hours;
+ friend constexpr years
+ operator-(const year& __x, const year& __y) noexcept
+ { return years{int{__x} - int{__y}}; }
- /// time_point
- template<typename _Clock, typename _Dur>
- struct time_point
- {
- typedef _Clock clock;
- typedef _Dur duration;
- typedef typename duration::rep rep;
- typedef typename duration::period period;
+ friend constexpr year_month
+ operator/(const year& __y, int __m) noexcept;
- constexpr time_point() : __d(duration::zero())
- { }
+ friend constexpr year_month_day
+ operator/(const year& __y, const month_day& __md) noexcept;
- constexpr explicit time_point(const duration& __dur)
- : __d(__dur)
- { }
+ friend constexpr year_month_day
+ operator/(const month_day& __md, const year& __y) noexcept;
- // conversions
- template<typename _Dur2>
- constexpr time_point(const time_point<clock, _Dur2>& __t)
- : __d(__t.time_since_epoch())
- { }
+ friend constexpr year_month_day_last
+ operator/(const year& __y, const month_day_last& __mdl) noexcept;
- // observer
- constexpr duration
- time_since_epoch() const
- { return __d; }
+ friend constexpr year_month_day_last
+ operator/(const month_day_last& __mdl, const year& __y) noexcept;
- // arithmetic
- time_point&
- operator+=(const duration& __dur)
- {
- __d += __dur;
- return *this;
- }
+ friend constexpr year_month_weekday
+ operator/(const year& __y, const month_weekday& __mwd) noexcept;
- time_point&
- operator-=(const duration& __dur)
- {
- __d -= __dur;
- return *this;
- }
+ friend constexpr year_month_weekday
+ operator/(const month_weekday& __mwd, const year& __y) noexcept;
- // special values
- static constexpr time_point
- min()
- { return time_point(duration::min()); }
+ friend constexpr year_month_weekday_last
+ operator/(const year& __y, const month_weekday_last& __mwdl) noexcept;
- static constexpr time_point
- max()
- { return time_point(duration::max()); }
+ friend constexpr year_month_weekday_last
+ operator/(const month_weekday_last& __mwdl, const year& __y) noexcept;
+ };
- private:
- duration __d;
- };
+ // WEEKDAY
- /// time_point_cast
- template<typename _ToDur, typename _Clock, typename _Dur>
- constexpr typename enable_if<__is_duration<_ToDur>::value,
- time_point<_Clock, _ToDur>>::type
- time_point_cast(const time_point<_Clock, _Dur>& __t)
+ class weekday
+ {
+ private:
+ unsigned char _M_wd;
+
+ static constexpr weekday
+ _S_from_days(const days& __d)
{
- typedef time_point<_Clock, _ToDur> __time_point;
- return __time_point(duration_cast<_ToDur>(__t.time_since_epoch()));
+ using _Rep = days::rep;
+ using _URep = make_unsigned_t<_Rep>;
+ const auto __n = __d.count();
+ const auto __m = static_cast<_URep>(__n);
+
+ // 1970-01-01 (__n = 0, __m = 0 ) -> Thursday (4)
+ // 1969-31-12 (__n = -1, __m = _URep(-1)) -> Wednesday (3)
+ const auto __offset = __n >= 0 ? _URep(4) : 3 - _URep(-1) % 7 - 7;
+ return weekday((__m + __offset) % 7);
}
-#if __cplusplus > 201402L
- template<typename _ToDur, typename _Clock, typename _Dur>
+ public:
+ weekday() = default;
+
+ explicit constexpr
+ weekday(unsigned __wd) noexcept
+ : _M_wd(__wd == 7 ? 0 : __wd) // __wd % 7 ?
+ { }
+
constexpr
- enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
- floor(const time_point<_Clock, _Dur>& __tp)
+ weekday(const sys_days& __dp) noexcept
+ : weekday{_S_from_days(__dp.time_since_epoch())}
+ { }
+
+ explicit constexpr
+ weekday(const local_days& __dp) noexcept
+ : weekday{sys_days{__dp.time_since_epoch()}}
+ { }
+
+ constexpr weekday&
+ operator++() noexcept
{
- return time_point<_Clock, _ToDur>{
- chrono::floor<_ToDur>(__tp.time_since_epoch())};
+ *this += days{1};
+ return *this;
}
- template<typename _ToDur, typename _Clock, typename _Dur>
- constexpr
- enable_if_t<__is_duration<_ToDur>::value, time_point<_Clock, _ToDur>>
- ceil(const time_point<_Clock, _Dur>& __tp)
+ constexpr weekday
+ operator++(int) noexcept
{
- return time_point<_Clock, _ToDur>{
- chrono::ceil<_ToDur>(__tp.time_since_epoch())};
+ auto __ret = *this;
+ ++(*this);
+ return __ret;
}
- template<typename _ToDur, typename _Clock, typename _Dur>
- constexpr enable_if_t<
- __and_<__is_duration<_ToDur>,
- __not_<treat_as_floating_point<typename _ToDur::rep>>>::value,
- time_point<_Clock, _ToDur>>
- round(const time_point<_Clock, _Dur>& __tp)
+ constexpr weekday&
+ operator--() noexcept
{
- return time_point<_Clock, _ToDur>{
- chrono::round<_ToDur>(__tp.time_since_epoch())};
+ *this -= days{1};
+ return *this;
}
-#endif // C++17
- template<typename _Clock, typename _Dur1,
- typename _Rep2, typename _Period2>
- constexpr time_point<_Clock,
- typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
- operator+(const time_point<_Clock, _Dur1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
+ constexpr weekday
+ operator--(int) noexcept
{
- typedef duration<_Rep2, _Period2> __dur2;
- typedef typename common_type<_Dur1,__dur2>::type __ct;
- typedef time_point<_Clock, __ct> __time_point;
- return __time_point(__lhs.time_since_epoch() + __rhs);
+ auto __ret = *this;
+ --(*this);
+ return __ret;
}
- template<typename _Rep1, typename _Period1,
- typename _Clock, typename _Dur2>
- constexpr time_point<_Clock,
- typename common_type<duration<_Rep1, _Period1>, _Dur2>::type>
- operator+(const duration<_Rep1, _Period1>& __lhs,
- const time_point<_Clock, _Dur2>& __rhs)
+ constexpr weekday&
+ operator+=(const days& __d) noexcept
{
- typedef duration<_Rep1, _Period1> __dur1;
- typedef typename common_type<__dur1,_Dur2>::type __ct;
- typedef time_point<_Clock, __ct> __time_point;
- return __time_point(__rhs.time_since_epoch() + __lhs);
+ *this = *this + __d;
+ return *this;
}
- template<typename _Clock, typename _Dur1,
- typename _Rep2, typename _Period2>
- constexpr time_point<_Clock,
- typename common_type<_Dur1, duration<_Rep2, _Period2>>::type>
- operator-(const time_point<_Clock, _Dur1>& __lhs,
- const duration<_Rep2, _Period2>& __rhs)
+ constexpr weekday&
+ operator-=(const days& __d) noexcept
{
- typedef duration<_Rep2, _Period2> __dur2;
- typedef typename common_type<_Dur1,__dur2>::type __ct;
- typedef time_point<_Clock, __ct> __time_point;
- return __time_point(__lhs.time_since_epoch() -__rhs);
+ *this = *this - __d;
+ return *this;
}
- template<typename _Clock, typename _Dur1, typename _Dur2>
- constexpr typename common_type<_Dur1, _Dur2>::type
- operator-(const time_point<_Clock, _Dur1>& __lhs,
- const time_point<_Clock, _Dur2>& __rhs)
- { return __lhs.time_since_epoch() - __rhs.time_since_epoch(); }
-
- template<typename _Clock, typename _Dur1, typename _Dur2>
- constexpr bool
- operator==(const time_point<_Clock, _Dur1>& __lhs,
- const time_point<_Clock, _Dur2>& __rhs)
- { return __lhs.time_since_epoch() == __rhs.time_since_epoch(); }
-
- template<typename _Clock, typename _Dur1, typename _Dur2>
- constexpr bool
- operator!=(const time_point<_Clock, _Dur1>& __lhs,
- const time_point<_Clock, _Dur2>& __rhs)
- { return !(__lhs == __rhs); }
-
- template<typename _Clock, typename _Dur1, typename _Dur2>
- constexpr bool
- operator<(const time_point<_Clock, _Dur1>& __lhs,
- const time_point<_Clock, _Dur2>& __rhs)
- { return __lhs.time_since_epoch() < __rhs.time_since_epoch(); }
-
- template<typename _Clock, typename _Dur1, typename _Dur2>
- constexpr bool
- operator<=(const time_point<_Clock, _Dur1>& __lhs,
- const time_point<_Clock, _Dur2>& __rhs)
- { return !(__rhs < __lhs); }
+ constexpr unsigned
+ c_encoding() const noexcept
+ { return _M_wd; }
- template<typename _Clock, typename _Dur1, typename _Dur2>
- constexpr bool
- operator>(const time_point<_Clock, _Dur1>& __lhs,
- const time_point<_Clock, _Dur2>& __rhs)
- { return __rhs < __lhs; }
+ constexpr unsigned
+ iso_encoding() const noexcept
+ { return _M_wd == 0u ? 7u : _M_wd; }
- template<typename _Clock, typename _Dur1, typename _Dur2>
constexpr bool
- operator>=(const time_point<_Clock, _Dur1>& __lhs,
- const time_point<_Clock, _Dur2>& __rhs)
- { return !(__lhs < __rhs); }
-
-
- // Clocks.
-
- // Why nanosecond resolution as the default?
- // Why have std::system_clock always count in the highest
- // resolution (ie nanoseconds), even if on some OSes the low 3
- // or 9 decimal digits will be always zero? This allows later
- // implementations to change the system_clock::now()
- // implementation any time to provide better resolution without
- // changing function signature or units.
-
- // To support the (forward) evolution of the library's defined
- // clocks, wrap inside inline namespace so that the current
- // defintions of system_clock, steady_clock, and
- // high_resolution_clock types are uniquely mangled. This way, new
- // code can use the latests clocks, while the library can contain
- // compatibility definitions for previous versions. At some
- // point, when these clocks settle down, the inlined namespaces
- // can be removed. XXX GLIBCXX_ABI Deprecated
- inline namespace _V2 {
-
- /**
- * @brief System clock.
- *
- * Time returned represents wall time from the system-wide clock.
- */
- struct system_clock
- {
- typedef chrono::nanoseconds duration;
- typedef duration::rep rep;
- typedef duration::period period;
- typedef chrono::time_point<system_clock, duration> time_point;
+ ok() const noexcept
+ { return _M_wd <= 6; }
- static_assert(system_clock::duration::min()
- < system_clock::duration::zero(),
- "a clock's minimum duration cannot be less than its epoch");
+ constexpr weekday_indexed
+ operator[](unsigned __index) const noexcept;
- static constexpr bool is_steady = false;
+ constexpr weekday_last
+ operator[](last_spec) const noexcept;
- static time_point
- now() noexcept;
+ friend constexpr bool
+ operator==(const weekday& __x, const weekday& __y) noexcept
+ { return __x._M_wd == __y._M_wd; }
- // Map to C API
- static std::time_t
- to_time_t(const time_point& __t) noexcept
+ friend constexpr weekday
+ operator+(const weekday& __x, const days& __y) noexcept
{
- return std::time_t(duration_cast<chrono::seconds>
- (__t.time_since_epoch()).count());
+ auto __n = static_cast<long long>(__x._M_wd) + __y.count();
+ return weekday{__detail::__modulo(__n, 7)};
}
- static time_point
- from_time_t(std::time_t __t) noexcept
+ friend constexpr weekday
+ operator+(const days& __x, const weekday& __y) noexcept
+ { return __y + __x; }
+
+ friend constexpr weekday
+ operator-(const weekday& __x, const days& __y) noexcept
+ { return __x + -__y; }
+
+ friend constexpr days
+ operator-(const weekday& __x, const weekday& __y) noexcept
{
- typedef chrono::time_point<system_clock, seconds> __from;
- return time_point_cast<system_clock::duration>
- (__from(chrono::seconds(__t)));
+ const auto __n = __x.c_encoding() - __y.c_encoding();
+ return static_cast<int>(__n) >= 0 ? days{__n} : days{__n + 7};
}
};
+ inline constexpr weekday Sunday{0};
+ inline constexpr weekday Monday{1};
+ inline constexpr weekday Tuesday{2};
+ inline constexpr weekday Wednesday{3};
+ inline constexpr weekday Thursday{4};
+ inline constexpr weekday Friday{5};
+ inline constexpr weekday Saturday{6};
- /**
- * @brief Monotonic clock
- *
- * Time returned has the property of only increasing at a uniform rate.
- */
- struct steady_clock
+ // WEEKDAY_INDEXED
+
+ class weekday_indexed
{
- typedef chrono::nanoseconds duration;
- typedef duration::rep rep;
- typedef duration::period period;
- typedef chrono::time_point<steady_clock, duration> time_point;
+ private:
+ chrono::weekday _M_wd;
+ unsigned char _M_index;
- static constexpr bool is_steady = true;
+ public:
+ weekday_indexed() = default;
- static time_point
- now() noexcept;
+ constexpr
+ weekday_indexed(const chrono::weekday& __wd, unsigned __index) noexcept
+ : _M_wd(__wd), _M_index(__index)
+ { }
+
+ constexpr chrono::weekday
+ weekday() const noexcept
+ { return _M_wd; }
+
+ constexpr unsigned
+ index() const noexcept
+ { return _M_index; };
+
+ constexpr bool
+ ok() const noexcept
+ { return _M_wd.ok() && 1 <= _M_index && _M_index <= 5; }
+
+ friend constexpr bool
+ operator==(const weekday_indexed& __x, const weekday_indexed& __y) noexcept
+ { return __x.weekday() == __y.weekday() && __x.index() == __y.index(); }
+
+ friend constexpr month_weekday
+ operator/(const month& __m, const weekday_indexed& __wdi) noexcept;
+
+ friend constexpr month_weekday
+ operator/(int __m, const weekday_indexed& __wdi) noexcept;
+
+ friend constexpr month_weekday
+ operator/(const weekday_indexed& __wdi, const month& __m) noexcept;
+
+ friend constexpr month_weekday
+ operator/(const weekday_indexed& __wdi, int __m) noexcept;
+
+ friend constexpr year_month_weekday
+ operator/(const year_month& __ym, const weekday_indexed& __wdi) noexcept;
};
+ constexpr weekday_indexed
+ weekday::operator[](unsigned __index) const noexcept
+ { return {*this, __index}; }
- /**
- * @brief Highest-resolution clock
- *
- * This is the clock "with the shortest tick period." Alias to
- * std::system_clock until higher-than-nanosecond definitions
- * become feasible.
- */
- using high_resolution_clock = system_clock;
+ // WEEKDAY_LAST
+
+ class weekday_last
+ {
+ private:
+ chrono::weekday _M_wd;
- } // end inline namespace _V2
+ public:
+ explicit constexpr
+ weekday_last(const chrono::weekday& __wd) noexcept
+ : _M_wd{__wd}
+ { }
- _GLIBCXX_END_NAMESPACE_VERSION
- } // namespace chrono
+ constexpr chrono::weekday
+ weekday() const noexcept
+ { return _M_wd; }
-#if __cplusplus > 201103L
+ constexpr bool
+ ok() const noexcept
+ { return _M_wd.ok(); }
-#define __cpp_lib_chrono_udls 201304
+ friend constexpr bool
+ operator==(const weekday_last& __x, const weekday_last& __y) noexcept
+ { return __x.weekday() == __y.weekday(); }
- inline namespace literals
- {
- inline namespace chrono_literals
- {
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ friend constexpr month_weekday_last
+ operator/(int __m, const weekday_last& __wdl) noexcept;
- template<typename _Rep, unsigned long long _Val>
- struct _Checked_integral_constant
- : integral_constant<_Rep, static_cast<_Rep>(_Val)>
- {
- static_assert(_Checked_integral_constant::value >= 0
- && _Checked_integral_constant::value == _Val,
- "literal value cannot be represented by duration type");
- };
+ friend constexpr month_weekday_last
+ operator/(const weekday_last& __wdl, int __m) noexcept;
- template<typename _Dur, char... _Digits>
- constexpr _Dur __check_overflow()
- {
- using _Val = __parse_int::_Parse_int<_Digits...>;
- using _Rep = typename _Dur::rep;
- // TODO: should be simply integral_constant<_Rep, _Val::value>
- // but GCC doesn't reject narrowing conversions to _Rep.
- using _CheckedVal = _Checked_integral_constant<_Rep, _Val::value>;
- return _Dur{_CheckedVal::value};
- }
+ friend constexpr year_month_weekday_last
+ operator/(const year_month& __ym, const weekday_last& __wdl) noexcept;
+ };
+
+ constexpr weekday_last
+ weekday::operator[](last_spec) const noexcept
+ { return weekday_last{*this}; }
+
+ // MONTH_DAY
+
+ class month_day
+ {
+ private:
+ chrono::month _M_m;
+ chrono::day _M_d;
- constexpr chrono::duration<long double, ratio<3600,1>>
- operator""h(long double __hours)
- { return chrono::duration<long double, ratio<3600,1>>{__hours}; }
+ public:
+ month_day() = default;
- template <char... _Digits>
- constexpr chrono::hours
- operator""h()
- { return __check_overflow<chrono::hours, _Digits...>(); }
+ constexpr
+ month_day(const chrono::month& __m, const chrono::day& __d) noexcept
+ : _M_m{__m}, _M_d{__d}
+ { }
- constexpr chrono::duration<long double, ratio<60,1>>
- operator""min(long double __mins)
- { return chrono::duration<long double, ratio<60,1>>{__mins}; }
+ constexpr chrono::month
+ month() const noexcept
+ { return _M_m; }
- template <char... _Digits>
- constexpr chrono::minutes
- operator""min()
- { return __check_overflow<chrono::minutes, _Digits...>(); }
+ constexpr chrono::day
+ day() const noexcept
+ { return _M_d; }
- constexpr chrono::duration<long double>
- operator""s(long double __secs)
- { return chrono::duration<long double>{__secs}; }
+ constexpr bool
+ ok() const noexcept
+ {
+ return _M_m.ok()
+ && 1u <= unsigned(_M_d)
+ && unsigned(_M_d) <= __detail::__days_per_month[unsigned(_M_m) - 1];
+ }
- template <char... _Digits>
- constexpr chrono::seconds
- operator""s()
- { return __check_overflow<chrono::seconds, _Digits...>(); }
+ friend constexpr bool
+ operator==(const month_day& __x, const month_day& __y) noexcept
+ { return __x.month() == __y.month() && __x.day() == __y.day(); }
- constexpr chrono::duration<long double, milli>
- operator""ms(long double __msecs)
- { return chrono::duration<long double, milli>{__msecs}; }
+ friend constexpr strong_ordering
+ operator<=>(const month_day& __x, const month_day& __y) noexcept
+ = default;
- template <char... _Digits>
- constexpr chrono::milliseconds
- operator""ms()
- { return __check_overflow<chrono::milliseconds, _Digits...>(); }
+ friend constexpr month_day
+ operator/(const chrono::month& __m, const chrono::day& __d) noexcept
+ { return {__m, __d}; }
- constexpr chrono::duration<long double, micro>
- operator""us(long double __usecs)
- { return chrono::duration<long double, micro>{__usecs}; }
+ friend constexpr month_day
+ operator/(const chrono::month& __m, int __d) noexcept
+ { return {__m, chrono::day(unsigned(__d))}; }
- template <char... _Digits>
- constexpr chrono::microseconds
- operator""us()
- { return __check_overflow<chrono::microseconds, _Digits...>(); }
+ friend constexpr month_day
+ operator/(int __m, const chrono::day& __d) noexcept
+ { return {chrono::month(unsigned(__m)), __d}; }
- constexpr chrono::duration<long double, nano>
- operator""ns(long double __nsecs)
- { return chrono::duration<long double, nano>{__nsecs}; }
+ friend constexpr month_day
+ operator/(const chrono::day& __d, const chrono::month& __m) noexcept
+ { return {__m, __d}; }
- template <char... _Digits>
- constexpr chrono::nanoseconds
- operator""ns()
- { return __check_overflow<chrono::nanoseconds, _Digits...>(); }
+ friend constexpr month_day
+ operator/(const chrono::day& __d, int __m) noexcept
+ { return {chrono::month(unsigned(__m)), __d}; }
- _GLIBCXX_END_NAMESPACE_VERSION
- } // inline namespace chrono_literals
- } // inline namespace literals
+ friend constexpr year_month_day
+ operator/(int __y, const month_day& __md) noexcept;
- namespace chrono
- {
- _GLIBCXX_BEGIN_NAMESPACE_VERSION
+ friend constexpr year_month_day
+ operator/(const month_day& __md, int __y) noexcept;
+ };
- using namespace literals::chrono_literals;
+ // MONTH_DAY_LAST
- _GLIBCXX_END_NAMESPACE_VERSION
- } // namespace chrono
+ class month_day_last
+ {
+ private:
+ chrono::month _M_m;
-#endif // __cplusplus > 201103L
+ public:
+ explicit constexpr
+ month_day_last(const chrono::month& __m) noexcept
+ : _M_m{__m}
+ { }
- // @} group chrono
+ constexpr chrono::month
+ month() const noexcept
+ { return _M_m; }
+
+ constexpr bool
+ ok() const noexcept
+ { return _M_m.ok(); }
+
+ friend constexpr bool
+ operator==(const month_day_last& __x, const month_day_last& __y) noexcept
+ { return __x.month() == __y.month(); }
+
+ friend constexpr strong_ordering
+ operator<=>(const month_day_last& __x, const month_day_last& __y) noexcept
+ = default;
+
+ friend constexpr month_day_last
+ operator/(const chrono::month& __m, last_spec) noexcept
+ { return month_day_last{__m}; }
+
+ friend constexpr month_day_last
+ operator/(int __m, last_spec) noexcept
+ { return chrono::month(unsigned(__m)) / last; }
+
+ friend constexpr month_day_last
+ operator/(last_spec, const chrono::month& __m) noexcept
+ { return __m / last; }
+
+ friend constexpr month_day_last
+ operator/(last_spec, int __m) noexcept
+ { return __m / last; }
+
+ friend constexpr year_month_day_last
+ operator/(int __y, const month_day_last& __mdl) noexcept;
+
+ friend constexpr year_month_day_last
+ operator/(const month_day_last& __mdl, int __y) noexcept;
+ };
+
+ // MONTH_WEEKDAY
+
+ class month_weekday
+ {
+ private:
+ chrono::month _M_m;
+ chrono::weekday_indexed _M_wdi;
+
+ public:
+ constexpr
+ month_weekday(const chrono::month& __m,
+ const chrono::weekday_indexed& __wdi) noexcept
+ : _M_m{__m}, _M_wdi{__wdi}
+ { }
+
+ constexpr chrono::month
+ month() const noexcept
+ { return _M_m; }
+
+ constexpr chrono::weekday_indexed
+ weekday_indexed() const noexcept
+ { return _M_wdi; }
+
+ constexpr bool
+ ok() const noexcept
+ { return _M_m.ok() && _M_wdi.ok(); }
+
+ friend constexpr bool
+ operator==(const month_weekday& __x, const month_weekday& __y) noexcept
+ {
+ return __x.month() == __y.month()
+ && __x.weekday_indexed() == __y.weekday_indexed();
+ }
+
+ friend constexpr month_weekday
+ operator/(const chrono::month& __m,
+ const chrono::weekday_indexed& __wdi) noexcept
+ { return {__m, __wdi}; }
+
+ friend constexpr month_weekday
+ operator/(int __m, const chrono::weekday_indexed& __wdi) noexcept
+ { return chrono::month(unsigned(__m)) / __wdi; }
+
+ friend constexpr month_weekday
+ operator/(const chrono::weekday_indexed& __wdi,
+ const chrono::month& __m) noexcept
+ { return __m / __wdi; }
+
+ friend constexpr month_weekday
+ operator/(const chrono::weekday_indexed& __wdi, int __m) noexcept
+ { return __m / __wdi; }
+
+ friend constexpr year_month_weekday
+ operator/(int __y, const month_weekday& __mwd) noexcept;
+
+ friend constexpr year_month_weekday
+ operator/(const month_weekday& __mwd, int __y) noexcept;
+ };
+
+ // MONTH_WEEKDAY_LAST
+
+ class month_weekday_last
+ {
+ private:
+ chrono::month _M_m;
+ chrono::weekday_last _M_wdl;
+
+ public:
+ constexpr
+ month_weekday_last(const chrono::month& __m,
+ const chrono::weekday_last& __wdl) noexcept
+ :_M_m{__m}, _M_wdl{__wdl}
+ { }
+
+ constexpr chrono::month
+ month() const noexcept
+ { return _M_m; }
+
+ constexpr chrono::weekday_last
+ weekday_last() const noexcept
+ { return _M_wdl; }
+
+ constexpr bool
+ ok() const noexcept
+ { return _M_m.ok() && _M_wdl.ok(); }
+
+ friend constexpr bool
+ operator==(const month_weekday_last& __x,
+ const month_weekday_last& __y) noexcept
+ {
+ return __x.month() == __y.month()
+ && __x.weekday_last() == __y.weekday_last();
+ }
+
+ friend constexpr month_weekday_last
+ operator/(const chrono::month& __m,
+ const chrono::weekday_last& __wdl) noexcept
+ { return {__m, __wdl}; }
+
+ friend constexpr month_weekday_last
+ operator/(int __m, const chrono::weekday_last& __wdl) noexcept
+ { return chrono::month(unsigned(__m)) / __wdl; }
+
+ friend constexpr month_weekday_last
+ operator/(const chrono::weekday_last& __wdl,
+ const chrono::month& __m) noexcept
+ { return __m / __wdl; }
+
+ friend constexpr month_weekday_last
+ operator/(const chrono::weekday_last& __wdl, int __m) noexcept
+ { return chrono::month(unsigned(__m)) / __wdl; }
+
+ friend constexpr year_month_weekday_last
+ operator/(int __y, const month_weekday_last& __mwdl) noexcept;
+
+ friend constexpr year_month_weekday_last
+ operator/(const month_weekday_last& __mwdl, int __y) noexcept;
+ };
+
+ // YEAR_MONTH
+
+ namespace __detail
+ {
+ // [time.cal.ym], [time.cal.ymd], etc constrain the 'months'-based
+ // addition/subtraction operator overloads like so:
+ //
+ // Constraints: if the argument supplied by the caller for the months
+ // parameter is convertible to years, its implicit conversion sequence
+ // to years is worse than its implicit conversion sequence to months.
+ //
+ // We realize this constraint by templatizing the 'months'-based
+ // overloads (using a dummy defaulted template parameter), so that
+ // overload resolution doesn't select the 'months'-based overload unless
+ // the implicit conversion sequence to 'months' is better than that to
+ // 'years'.
+ using __months_years_conversion_disambiguator = void;
+ }
+
+ class year_month
+ {
+ private:
+ chrono::year _M_y;
+ chrono::month _M_m;
+
+ public:
+ year_month() = default;
+
+ constexpr
+ year_month(const chrono::year& __y, const chrono::month& __m) noexcept
+ : _M_y{__y}, _M_m{__m}
+ { }
+
+ constexpr chrono::year
+ year() const noexcept
+ { return _M_y; }
+
+ constexpr chrono::month
+ month() const noexcept
+ { return _M_m; }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month&
+ operator+=(const months& __dm) noexcept
+ {
+ *this = *this + __dm;
+ return *this;
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month&
+ operator-=(const months& __dm) noexcept
+ {
+ *this = *this - __dm;
+ return *this;
+ }
+
+ constexpr year_month&
+ operator+=(const years& __dy) noexcept
+ {
+ *this = *this + __dy;
+ return *this;
+ }
+
+ constexpr year_month&
+ operator-=(const years& __dy) noexcept
+ {
+ *this = *this - __dy;
+ return *this;
+ }
+
+ constexpr bool
+ ok() const noexcept
+ { return _M_y.ok() && _M_m.ok(); }
+
+ friend constexpr bool
+ operator==(const year_month& __x, const year_month& __y) noexcept
+ { return __x.year() == __y.year() && __x.month() == __y.month(); }
+
+ friend constexpr strong_ordering
+ operator<=>(const year_month& __x, const year_month& __y) noexcept
+ = default;
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month
+ operator+(const year_month& __ym, const months& __dm) noexcept
+ {
+ // TODO: Optimize?
+ auto __m = __ym.month() + __dm;
+ auto __i = int(unsigned(__ym.month())) - 1 + __dm.count();
+ auto __y = (__i < 0
+ ? __ym.year() + years{(__i - 11) / 12}
+ : __ym.year() + years{__i / 12});
+ return __y / __m;
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month
+ operator+(const months& __dm, const year_month& __ym) noexcept
+ { return __ym + __dm; }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month
+ operator-(const year_month& __ym, const months& __dm) noexcept
+ { return __ym + -__dm; }
+
+ friend constexpr months
+ operator-(const year_month& __x, const year_month& __y) noexcept
+ {
+ return (__x.year() - __y.year()
+ + months{static_cast<int>(unsigned{__x.month()})
+ - static_cast<int>(unsigned{__y.month()})});
+ }
+
+ friend constexpr year_month
+ operator+(const year_month& __ym, const years& __dy) noexcept
+ { return (__ym.year() + __dy) / __ym.month(); }
+
+ friend constexpr year_month
+ operator+(const years& __dy, const year_month& __ym) noexcept
+ { return __ym + __dy; }
+
+ friend constexpr year_month
+ operator-(const year_month& __ym, const years& __dy) noexcept
+ { return __ym + -__dy; }
+
+ friend constexpr year_month
+ operator/(const chrono::year& __y, const chrono::month& __m) noexcept
+ { return {__y, __m}; }
+
+ friend constexpr year_month
+ operator/(const chrono::year& __y, int __m) noexcept
+ { return {__y, chrono::month(unsigned(__m))}; }
+
+ friend constexpr year_month_day
+ operator/(const year_month& __ym, int __d) noexcept;
+
+ friend constexpr year_month_day_last
+ operator/(const year_month& __ym, last_spec) noexcept;
+ };
+
+ // YEAR_MONTH_DAY
+
+ class year_month_day
+ {
+ private:
+ chrono::year _M_y;
+ chrono::month _M_m;
+ chrono::day _M_d;
+
+ static constexpr year_month_day _S_from_days(const days& __dp) noexcept;
+
+ constexpr days _M_days_since_epoch() const noexcept;
+
+ public:
+ year_month_day() = default;
+
+ constexpr
+ year_month_day(const chrono::year& __y, const chrono::month& __m,
+ const chrono::day& __d) noexcept
+ : _M_y{__y}, _M_m{__m}, _M_d{__d}
+ { }
+
+ constexpr
+ year_month_day(const year_month_day_last& __ymdl) noexcept;
+
+ constexpr
+ year_month_day(const sys_days& __dp) noexcept
+ : year_month_day(_S_from_days(__dp.time_since_epoch()))
+ { }
+
+ explicit constexpr
+ year_month_day(const local_days& __dp) noexcept
+ : year_month_day(sys_days{__dp.time_since_epoch()})
+ { }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month_day&
+ operator+=(const months& __m) noexcept
+ {
+ *this = *this + __m;
+ return *this;
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month_day&
+ operator-=(const months& __m) noexcept
+ {
+ *this = *this - __m;
+ return *this;
+ }
+
+ constexpr year_month_day&
+ operator+=(const years& __y) noexcept
+ {
+ *this = *this + __y;
+ return *this;
+ }
+
+ constexpr year_month_day&
+ operator-=(const years& __y) noexcept
+ {
+ *this = *this - __y;
+ return *this;
+ }
+
+ constexpr chrono::year
+ year() const noexcept
+ { return _M_y; }
+
+ constexpr chrono::month
+ month() const noexcept
+ { return _M_m; }
+
+ constexpr chrono::day
+ day() const noexcept
+ { return _M_d; }
+
+ constexpr
+ operator sys_days() const noexcept
+ { return sys_days{_M_days_since_epoch()}; }
+
+ explicit constexpr
+ operator local_days() const noexcept
+ { return local_days{sys_days{*this}.time_since_epoch()}; }
+
+ constexpr bool ok() const noexcept;
+
+ friend constexpr bool
+ operator==(const year_month_day& __x, const year_month_day& __y) noexcept
+ {
+ return __x.year() == __y.year()
+ && __x.month() == __y.month()
+ && __x.day() == __y.day();
+ }
+
+ friend constexpr strong_ordering
+ operator<=>(const year_month_day& __x, const year_month_day& __y) noexcept
+ = default;
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_day
+ operator+(const year_month_day& __ymd, const months& __dm) noexcept
+ { return (__ymd.year() / __ymd.month() + __dm) / __ymd.day(); }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_day
+ operator+(const months& __dm, const year_month_day& __ymd) noexcept
+ { return __ymd + __dm; }
+
+ friend constexpr year_month_day
+ operator+(const year_month_day& __ymd, const years& __dy) noexcept
+ { return (__ymd.year() + __dy) / __ymd.month() / __ymd.day(); }
+
+ friend constexpr year_month_day
+ operator+(const years& __dy, const year_month_day& __ymd) noexcept
+ { return __ymd + __dy; }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_day
+ operator-(const year_month_day& __ymd, const months& __dm) noexcept
+ { return __ymd + -__dm; }
+
+ friend constexpr year_month_day
+ operator-(const year_month_day& __ymd, const years& __dy) noexcept
+ { return __ymd + -__dy; }
+
+ friend constexpr year_month_day
+ operator/(const year_month& __ym, const chrono::day& __d) noexcept
+ { return {__ym.year(), __ym.month(), __d}; }
+
+ friend constexpr year_month_day
+ operator/(const year_month& __ym, int __d) noexcept
+ { return __ym / chrono::day{unsigned(__d)}; }
+
+ friend constexpr year_month_day
+ operator/(const chrono::year& __y, const month_day& __md) noexcept
+ { return __y / __md.month() / __md.day(); }
+
+ friend constexpr year_month_day
+ operator/(int __y, const month_day& __md) noexcept
+ { return chrono::year{__y} / __md; }
+
+ friend constexpr year_month_day
+ operator/(const month_day& __md, const chrono::year& __y) noexcept
+ { return __y / __md; }
+
+ friend constexpr year_month_day
+ operator/(const month_day& __md, int __y) noexcept
+ { return chrono::year(__y) / __md; }
+ };
+
+ // Construct from days since 1970/01/01.
+ // Proposition 6.3 of Neri and Schneider,
+ // "Euclidean Affine Functions and Applications to Calendar Algorithms".
+ // https://arxiv.org/abs/2102.06959
+ constexpr year_month_day
+ year_month_day::_S_from_days(const days& __dp) noexcept
+ {
+ constexpr auto __z2 = static_cast<uint32_t>(-1468000);
+ constexpr auto __r2_e3 = static_cast<uint32_t>(536895458);
+
+ const auto __r0 = static_cast<uint32_t>(__dp.count()) + __r2_e3;
+
+ const auto __n1 = 4 * __r0 + 3;
+ const auto __q1 = __n1 / 146097;
+ const auto __r1 = __n1 % 146097 / 4;
+
+ constexpr auto __p32 = static_cast<uint64_t>(1) << 32;
+ const auto __n2 = 4 * __r1 + 3;
+ const auto __u2 = static_cast<uint64_t>(2939745) * __n2;
+ const auto __q2 = static_cast<uint32_t>(__u2 / __p32);
+ const auto __r2 = static_cast<uint32_t>(__u2 % __p32) / 2939745 / 4;
+
+ constexpr auto __p16 = static_cast<uint32_t>(1) << 16;
+ const auto __n3 = 2141 * __r2 + 197913;
+ const auto __q3 = __n3 / __p16;
+ const auto __r3 = __n3 % __p16 / 2141;
+
+ const auto __y0 = 100 * __q1 + __q2;
+ const auto __m0 = __q3;
+ const auto __d0 = __r3;
+
+ const auto __j = __r2 >= 306;
+ const auto __y1 = __y0 + __j;
+ const auto __m1 = __j ? __m0 - 12 : __m0;
+ const auto __d1 = __d0 + 1;
+
+ return year_month_day{chrono::year{static_cast<int>(__y1 + __z2)},
+ chrono::month{__m1}, chrono::day{__d1}};
+ }
+
+ // Days since 1970/01/01.
+ // Proposition 6.2 of Neri and Schneider,
+ // "Euclidean Affine Functions and Applications to Calendar Algorithms".
+ // https://arxiv.org/abs/2102.06959
+ constexpr days
+ year_month_day::_M_days_since_epoch() const noexcept
+ {
+ auto constexpr __z2 = static_cast<uint32_t>(-1468000);
+ auto constexpr __r2_e3 = static_cast<uint32_t>(536895458);
+
+ const auto __y1 = static_cast<uint32_t>(static_cast<int>(_M_y)) - __z2;
+ const auto __m1 = static_cast<uint32_t>(static_cast<unsigned>(_M_m));
+ const auto __d1 = static_cast<uint32_t>(static_cast<unsigned>(_M_d));
+
+ const auto __j = static_cast<uint32_t>(__m1 < 3);
+ const auto __y0 = __y1 - __j;
+ const auto __m0 = __j ? __m1 + 12 : __m1;
+ const auto __d0 = __d1 - 1;
+
+ const auto __q1 = __y0 / 100;
+ const auto __yc = 1461 * __y0 / 4 - __q1 + __q1 / 4;
+ const auto __mc = (979 *__m0 - 2919) / 32;
+ const auto __dc = __d0;
+
+ return days{static_cast<int32_t>(__yc + __mc + __dc - __r2_e3)};
+ }
+
+ // YEAR_MONTH_DAY_LAST
+
+ class year_month_day_last
+ {
+ private:
+ chrono::year _M_y;
+ chrono::month_day_last _M_mdl;
+
+ public:
+ constexpr
+ year_month_day_last(const chrono::year& __y,
+ const chrono::month_day_last& __mdl) noexcept
+ : _M_y{__y}, _M_mdl{__mdl}
+ { }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month_day_last&
+ operator+=(const months& __m) noexcept
+ {
+ *this = *this + __m;
+ return *this;
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month_day_last&
+ operator-=(const months& __m) noexcept
+ {
+ *this = *this - __m;
+ return *this;
+ }
+
+ constexpr year_month_day_last&
+ operator+=(const years& __y) noexcept
+ {
+ *this = *this + __y;
+ return *this;
+ }
+
+ constexpr year_month_day_last&
+ operator-=(const years& __y) noexcept
+ {
+ *this = *this - __y;
+ return *this;
+ }
+
+ constexpr chrono::year
+ year() const noexcept
+ { return _M_y; }
+
+ constexpr chrono::month
+ month() const noexcept
+ { return _M_mdl.month(); }
+
+ constexpr chrono::month_day_last
+ month_day_last() const noexcept
+ { return _M_mdl; }
+
+ // Return A day representing the last day of this year, month pair.
+ constexpr chrono::day
+ day() const noexcept
+ {
+ const auto __m = static_cast<unsigned>(month());
+
+ // The result is unspecified if __m < 1 or __m > 12. Hence, assume
+ // 1 <= __m <= 12. For __m != 2, day() == 30 or day() == 31 or, in
+ // other words, day () == 30 | b, where b is in {0, 1}.
+
+ // If __m in {1, 3, 4, 5, 6, 7}, then b is 1 if, and only if, __m is
+ // odd. Hence, b = __m & 1 = (__m ^ 0) & 1.
+
+ // If __m in {8, 9, 10, 11, 12}, then b is 1 if, and only if, __m is
+ // even. Hence, b = (__m ^ 1) & 1.
+
+ // Therefore, b = (__m ^ c) & 1, where c = 0, if __m < 8, or c = 1 if
+ // __m >= 8, that is, c = __m >> 3.
+
+ // Since 30 = (11110)_2 and __m <= 31 = (11111)_2, the "& 1" in b's
+ // calculation is unnecessary.
+
+ // The performance of this implementation does not depend on look-up
+ // tables being on the L1 cache.
+ return chrono::day{__m != 2 ? (__m ^ (__m >> 3)) | 30
+ : _M_y.is_leap() ? 29 : 28};
+ }
+
+ constexpr
+ operator sys_days() const noexcept
+ { return sys_days{year() / month() / day()}; }
+
+ explicit constexpr
+ operator local_days() const noexcept
+ { return local_days{sys_days{*this}.time_since_epoch()}; }
+
+ constexpr bool
+ ok() const noexcept
+ { return _M_y.ok() && _M_mdl.ok(); }
+
+ friend constexpr bool
+ operator==(const year_month_day_last& __x,
+ const year_month_day_last& __y) noexcept
+ {
+ return __x.year() == __y.year()
+ && __x.month_day_last() == __y.month_day_last();
+ }
+
+ friend constexpr strong_ordering
+ operator<=>(const year_month_day_last& __x,
+ const year_month_day_last& __y) noexcept
+ = default;
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_day_last
+ operator+(const year_month_day_last& __ymdl,
+ const months& __dm) noexcept
+ { return (__ymdl.year() / __ymdl.month() + __dm) / last; }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_day_last
+ operator+(const months& __dm,
+ const year_month_day_last& __ymdl) noexcept
+ { return __ymdl + __dm; }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_day_last
+ operator-(const year_month_day_last& __ymdl,
+ const months& __dm) noexcept
+ { return __ymdl + -__dm; }
+
+ friend constexpr year_month_day_last
+ operator+(const year_month_day_last& __ymdl,
+ const years& __dy) noexcept
+ { return {__ymdl.year() + __dy, __ymdl.month_day_last()}; }
+
+ friend constexpr year_month_day_last
+ operator+(const years& __dy,
+ const year_month_day_last& __ymdl) noexcept
+ { return __ymdl + __dy; }
+
+ friend constexpr year_month_day_last
+ operator-(const year_month_day_last& __ymdl,
+ const years& __dy) noexcept
+ { return __ymdl + -__dy; }
+
+ friend constexpr year_month_day_last
+ operator/(const year_month& __ym, last_spec) noexcept
+ { return {__ym.year(), chrono::month_day_last{__ym.month()}}; }
+
+ friend constexpr year_month_day_last
+ operator/(const chrono::year& __y,
+ const chrono::month_day_last& __mdl) noexcept
+ { return {__y, __mdl}; }
+
+ friend constexpr year_month_day_last
+ operator/(int __y, const chrono::month_day_last& __mdl) noexcept
+ { return chrono::year(__y) / __mdl; }
+
+ friend constexpr year_month_day_last
+ operator/(const chrono::month_day_last& __mdl,
+ const chrono::year& __y) noexcept
+ { return __y / __mdl; }
+
+ friend constexpr year_month_day_last
+ operator/(const chrono::month_day_last& __mdl, int __y) noexcept
+ { return chrono::year(__y) / __mdl; }
+ };
+
+ // year_month_day ctor from year_month_day_last
+ constexpr
+ year_month_day::year_month_day(const year_month_day_last& __ymdl) noexcept
+ : _M_y{__ymdl.year()}, _M_m{__ymdl.month()}, _M_d{__ymdl.day()}
+ { }
+
+ constexpr bool
+ year_month_day::ok() const noexcept
+ {
+ if (!_M_y.ok() || !_M_m.ok())
+ return false;
+ return chrono::day{1} <= _M_d && _M_d <= (_M_y / _M_m / last).day();
+ }
+
+ // YEAR_MONTH_WEEKDAY
+
+ class year_month_weekday
+ {
+ private:
+ chrono::year _M_y;
+ chrono::month _M_m;
+ chrono::weekday_indexed _M_wdi;
+
+ static constexpr year_month_weekday
+ _S_from_sys_days(const sys_days& __dp)
+ {
+ year_month_day __ymd{__dp};
+ chrono::weekday __wd{__dp};
+ auto __index = __wd[(unsigned{__ymd.day()} - 1) / 7 + 1];
+ return {__ymd.year(), __ymd.month(), __index};
+ }
+
+ public:
+ year_month_weekday() = default;
+
+ constexpr
+ year_month_weekday(const chrono::year& __y, const chrono::month& __m,
+ const chrono::weekday_indexed& __wdi) noexcept
+ : _M_y{__y}, _M_m{__m}, _M_wdi{__wdi}
+ { }
+
+ constexpr
+ year_month_weekday(const sys_days& __dp) noexcept
+ : year_month_weekday{_S_from_sys_days(__dp)}
+ { }
+
+ explicit constexpr
+ year_month_weekday(const local_days& __dp) noexcept
+ : year_month_weekday{sys_days{__dp.time_since_epoch()}}
+ { }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month_weekday&
+ operator+=(const months& __m) noexcept
+ {
+ *this = *this + __m;
+ return *this;
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month_weekday&
+ operator-=(const months& __m) noexcept
+ {
+ *this = *this - __m;
+ return *this;
+ }
+
+ constexpr year_month_weekday&
+ operator+=(const years& __y) noexcept
+ {
+ *this = *this + __y;
+ return *this;
+ }
+
+ constexpr year_month_weekday&
+ operator-=(const years& __y) noexcept
+ {
+ *this = *this - __y;
+ return *this;
+ }
+
+ constexpr chrono::year
+ year() const noexcept
+ { return _M_y; }
+
+ constexpr chrono::month
+ month() const noexcept
+ { return _M_m; }
+
+ constexpr chrono::weekday
+ weekday() const noexcept
+ { return _M_wdi.weekday(); }
+
+ constexpr unsigned
+ index() const noexcept
+ { return _M_wdi.index(); }
+
+ constexpr chrono::weekday_indexed
+ weekday_indexed() const noexcept
+ { return _M_wdi; }
+
+ constexpr
+ operator sys_days() const noexcept
+ {
+ auto __d = sys_days{year() / month() / 1};
+ return __d + (weekday() - chrono::weekday(__d)
+ + days{(static_cast<int>(index())-1)*7});
+ }
+
+ explicit constexpr
+ operator local_days() const noexcept
+ { return local_days{sys_days{*this}.time_since_epoch()}; }
+
+ constexpr bool
+ ok() const noexcept
+ {
+ if (!_M_y.ok() || !_M_m.ok() || !_M_wdi.ok())
+ return false;
+ if (_M_wdi.index() <= 4)
+ return true;
+ days __d = (_M_wdi.weekday()
+ - chrono::weekday{sys_days{_M_y / _M_m / 1}}
+ + days((_M_wdi.index()-1)*7 + 1));
+ __glibcxx_assert(__d.count() >= 1);
+ return (unsigned)__d.count() <= (unsigned)(_M_y / _M_m / last).day();
+ }
+
+ friend constexpr bool
+ operator==(const year_month_weekday& __x,
+ const year_month_weekday& __y) noexcept
+ {
+ return __x.year() == __y.year()
+ && __x.month() == __y.month()
+ && __x.weekday_indexed() == __y.weekday_indexed();
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_weekday
+ operator+(const year_month_weekday& __ymwd, const months& __dm) noexcept
+ {
+ return ((__ymwd.year() / __ymwd.month() + __dm)
+ / __ymwd.weekday_indexed());
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_weekday
+ operator+(const months& __dm, const year_month_weekday& __ymwd) noexcept
+ { return __ymwd + __dm; }
+
+ friend constexpr year_month_weekday
+ operator+(const year_month_weekday& __ymwd, const years& __dy) noexcept
+ { return {__ymwd.year() + __dy, __ymwd.month(), __ymwd.weekday_indexed()}; }
+
+ friend constexpr year_month_weekday
+ operator+(const years& __dy, const year_month_weekday& __ymwd) noexcept
+ { return __ymwd + __dy; }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_weekday
+ operator-(const year_month_weekday& __ymwd, const months& __dm) noexcept
+ { return __ymwd + -__dm; }
+
+ friend constexpr year_month_weekday
+ operator-(const year_month_weekday& __ymwd, const years& __dy) noexcept
+ { return __ymwd + -__dy; }
+
+ friend constexpr year_month_weekday
+ operator/(const year_month& __ym,
+ const chrono::weekday_indexed& __wdi) noexcept
+ { return {__ym.year(), __ym.month(), __wdi}; }
+
+ friend constexpr year_month_weekday
+ operator/(const chrono::year& __y, const month_weekday& __mwd) noexcept
+ { return {__y, __mwd.month(), __mwd.weekday_indexed()}; }
+
+ friend constexpr year_month_weekday
+ operator/(int __y, const month_weekday& __mwd) noexcept
+ { return chrono::year(__y) / __mwd; }
+
+ friend constexpr year_month_weekday
+ operator/(const month_weekday& __mwd, const chrono::year& __y) noexcept
+ { return __y / __mwd; }
+
+ friend constexpr year_month_weekday
+ operator/(const month_weekday& __mwd, int __y) noexcept
+ { return chrono::year(__y) / __mwd; }
+ };
+
+ // YEAR_MONTH_WEEKDAY_LAST
+
+ class year_month_weekday_last
+ {
+ private:
+ chrono::year _M_y;
+ chrono::month _M_m;
+ chrono::weekday_last _M_wdl;
+
+ public:
+ constexpr
+ year_month_weekday_last(const chrono::year& __y, const chrono::month& __m,
+ const chrono::weekday_last& __wdl) noexcept
+ : _M_y{__y}, _M_m{__m}, _M_wdl{__wdl}
+ { }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month_weekday_last&
+ operator+=(const months& __m) noexcept
+ {
+ *this = *this + __m;
+ return *this;
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ constexpr year_month_weekday_last&
+ operator-=(const months& __m) noexcept
+ {
+ *this = *this - __m;
+ return *this;
+ }
+
+ constexpr year_month_weekday_last&
+ operator+=(const years& __y) noexcept
+ {
+ *this = *this + __y;
+ return *this;
+ }
+
+ constexpr year_month_weekday_last&
+ operator-=(const years& __y) noexcept
+ {
+ *this = *this - __y;
+ return *this;
+ }
+
+ constexpr chrono::year
+ year() const noexcept
+ { return _M_y; }
+
+ constexpr chrono::month
+ month() const noexcept
+ { return _M_m; }
+
+ constexpr chrono::weekday
+ weekday() const noexcept
+ { return _M_wdl.weekday(); }
+
+ constexpr chrono::weekday_last
+ weekday_last() const noexcept
+ { return _M_wdl; }
+
+ constexpr
+ operator sys_days() const noexcept
+ {
+ const auto __d = sys_days{_M_y / _M_m / last};
+ return sys_days{(__d - (chrono::weekday{__d}
+ - _M_wdl.weekday())).time_since_epoch()};
+ }
+
+ explicit constexpr
+ operator local_days() const noexcept
+ { return local_days{sys_days{*this}.time_since_epoch()}; }
+
+ constexpr bool
+ ok() const noexcept
+ { return _M_y.ok() && _M_m.ok() && _M_wdl.ok(); }
+
+ friend constexpr bool
+ operator==(const year_month_weekday_last& __x,
+ const year_month_weekday_last& __y) noexcept
+ {
+ return __x.year() == __y.year()
+ && __x.month() == __y.month()
+ && __x.weekday_last() == __y.weekday_last();
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_weekday_last
+ operator+(const year_month_weekday_last& __ymwdl,
+ const months& __dm) noexcept
+ {
+ return ((__ymwdl.year() / __ymwdl.month() + __dm)
+ / __ymwdl.weekday_last());
+ }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_weekday_last
+ operator+(const months& __dm,
+ const year_month_weekday_last& __ymwdl) noexcept
+ { return __ymwdl + __dm; }
+
+ friend constexpr year_month_weekday_last
+ operator+(const year_month_weekday_last& __ymwdl,
+ const years& __dy) noexcept
+ { return {__ymwdl.year() + __dy, __ymwdl.month(), __ymwdl.weekday_last()}; }
+
+ friend constexpr year_month_weekday_last
+ operator+(const years& __dy,
+ const year_month_weekday_last& __ymwdl) noexcept
+ { return __ymwdl + __dy; }
+
+ template<typename = __detail::__months_years_conversion_disambiguator>
+ friend constexpr year_month_weekday_last
+ operator-(const year_month_weekday_last& __ymwdl,
+ const months& __dm) noexcept
+ { return __ymwdl + -__dm; }
+
+ friend constexpr year_month_weekday_last
+ operator-(const year_month_weekday_last& __ymwdl,
+ const years& __dy) noexcept
+ { return __ymwdl + -__dy; }
+
+ friend constexpr year_month_weekday_last
+ operator/(const year_month& __ym,
+ const chrono::weekday_last& __wdl) noexcept
+ { return {__ym.year(), __ym.month(), __wdl}; }
+
+ friend constexpr year_month_weekday_last
+ operator/(const chrono::year& __y,
+ const chrono::month_weekday_last& __mwdl) noexcept
+ { return {__y, __mwdl.month(), __mwdl.weekday_last()}; }
+
+ friend constexpr year_month_weekday_last
+ operator/(int __y, const chrono::month_weekday_last& __mwdl) noexcept
+ { return chrono::year(__y) / __mwdl; }
+
+ friend constexpr year_month_weekday_last
+ operator/(const chrono::month_weekday_last& __mwdl,
+ const chrono::year& __y) noexcept
+ { return __y / __mwdl; }
+
+ friend constexpr year_month_weekday_last
+ operator/(const chrono::month_weekday_last& __mwdl, int __y) noexcept
+ { return chrono::year(__y) / __mwdl; }
+ };
+
+ // HH_MM_SS
+
+ /// @cond undocumented
+ namespace __detail
+ {
+ consteval long long
+ __pow10(unsigned __n)
+ {
+ long long __r = 1;
+ while (__n-- > 0)
+ __r *= 10;
+ return __r;
+ }
+
+ template<typename _Duration> struct __utc_leap_second;
+ }
+ /// @endcond
+
+ /** Utility for splitting a duration into hours, minutes, and seconds
+ *
+ * This is a convenience type that provides accessors for the constituent
+ * parts (hours, minutes, seconds and subseconds) of a duration.
+ *
+ * @since C++20
+ */
+ template<typename _Duration>
+ class hh_mm_ss
+ {
+ static_assert( __is_duration<_Duration>::value );
+
+ private:
+ static consteval int
+ _S_fractional_width()
+ {
+ auto __den = _Duration::period::den;
+ const int __multiplicity_2 = std::__countr_zero((uintmax_t)__den);
+ __den >>= __multiplicity_2;
+ int __multiplicity_5 = 0;
+ while ((__den % 5) == 0)
+ {
+ ++__multiplicity_5;
+ __den /= 5;
+ }
+ if (__den != 1)
+ return 6;
+
+ int __width = (__multiplicity_2 > __multiplicity_5
+ ? __multiplicity_2 : __multiplicity_5);
+ if (__width > 18)
+ __width = 18;
+ return __width;
+ }
+
+ constexpr
+ hh_mm_ss(_Duration __d, bool __is_neg)
+ : _M_h (duration_cast<chrono::hours>(__d)),
+ _M_m (duration_cast<chrono::minutes>(__d - hours())),
+ _M_s (duration_cast<chrono::seconds>(__d - hours() - minutes())),
+ _M_is_neg(__is_neg)
+ {
+ auto __ss = __d - hours() - minutes() - seconds();
+ if constexpr (treat_as_floating_point_v<typename precision::rep>)
+ _M_ss._M_r = __ss.count();
+ else if constexpr (precision::period::den != 1)
+ _M_ss._M_r = duration_cast<precision>(__ss).count();
+ }
+
+ static constexpr _Duration
+ _S_abs(_Duration __d)
+ {
+ if constexpr (numeric_limits<typename _Duration::rep>::is_signed)
+ return chrono::abs(__d);
+ else
+ return __d;
+ }
+
+ public:
+ static constexpr unsigned fractional_width = {_S_fractional_width()};
+
+ using precision
+ = duration<common_type_t<typename _Duration::rep,
+ chrono::seconds::rep>,
+ ratio<1, __detail::__pow10(fractional_width)>>;
+
+ constexpr hh_mm_ss() noexcept = default;
+
+ constexpr explicit
+ hh_mm_ss(_Duration __d)
+ : hh_mm_ss(_S_abs(__d), __d < _Duration::zero())
+ { }
+
+ constexpr bool
+ is_negative() const noexcept
+ {
+ if constexpr (!_S_is_unsigned)
+ return _M_is_neg;
+ else
+ return false;
+ }
+
+ constexpr chrono::hours
+ hours() const noexcept
+ { return _M_h; }
+
+ constexpr chrono::minutes
+ minutes() const noexcept
+ { return _M_m; }
+
+ constexpr chrono::seconds
+ seconds() const noexcept
+ { return _M_s; }
+
+ constexpr precision
+ subseconds() const noexcept
+ { return static_cast<precision>(_M_ss); }
+
+ constexpr explicit
+ operator precision() const noexcept
+ { return to_duration(); }
+
+ constexpr precision
+ to_duration() const noexcept
+ {
+ if constexpr (!_S_is_unsigned)
+ if (_M_is_neg)
+ return -(_M_h + _M_m + _M_s + subseconds());
+ return _M_h + _M_m + _M_s + subseconds();
+ }
+
+ private:
+ static constexpr bool _S_is_unsigned
+ = __and_v<is_integral<typename _Duration::rep>,
+ is_unsigned<typename _Duration::rep>>;
+
+ template<typename _Ratio>
+ using __byte_duration = duration<unsigned char, _Ratio>;
+
+ // The type of the _M_ss member that holds the subsecond precision.
+ template<typename _Dur>
+ struct __subseconds
+ {
+ typename _Dur::rep _M_r{};
+
+ constexpr explicit
+ operator _Dur() const noexcept
+ { return _Dur(_M_r); }
+ };
+
+ // An empty class if this precision doesn't need subseconds.
+ template<typename _Rep>
+ requires (!treat_as_floating_point_v<_Rep>)
+ struct __subseconds<duration<_Rep, ratio<1>>>
+ {
+ constexpr explicit
+ operator duration<_Rep, ratio<1>>() const noexcept
+ { return {}; }
+ };
+
+ template<typename _Rep, typename _Period>
+ requires (!treat_as_floating_point_v<_Rep>)
+ && ratio_less_v<_Period, ratio<1, 1>>
+ && ratio_greater_equal_v<_Period, ratio<1, 250>>
+ struct __subseconds<duration<_Rep, _Period>>
+ {
+ unsigned char _M_r{};
+
+ constexpr explicit
+ operator duration<_Rep, _Period>() const noexcept
+ { return duration<_Rep, _Period>(_M_r); }
+ };
+
+ template<typename _Rep, typename _Period>
+ requires (!treat_as_floating_point_v<_Rep>)
+ && ratio_less_v<_Period, ratio<1, 250>>
+ && ratio_greater_equal_v<_Period, ratio<1, 4000000000>>
+ struct __subseconds<duration<_Rep, _Period>>
+ {
+ uint_least32_t _M_r{};
+
+ constexpr explicit
+ operator duration<_Rep, _Period>() const noexcept
+ { return duration<_Rep, _Period>(_M_r); }
+ };
+
+ chrono::hours _M_h{};
+ __byte_duration<ratio<60>> _M_m{};
+ __byte_duration<ratio<1>> _M_s{};
+ bool _M_is_neg{};
+ __subseconds<precision> _M_ss{};
+
+ template<typename> friend struct __detail::__utc_leap_second;
+ };
+
+ /// @cond undocumented
+ namespace __detail
+ {
+ // Represents a time that is within a leap second insertion.
+ template<typename _Duration>
+ struct __utc_leap_second
+ {
+ explicit
+ __utc_leap_second(const sys_time<_Duration>& __s)
+ : _M_date(chrono::floor<days>(__s)), _M_time(__s - _M_date)
+ {
+ ++_M_time._M_s;
+ }
+
+ sys_days _M_date;
+ hh_mm_ss<common_type_t<_Duration, days>> _M_time;
+ };
+ }
+ /// @endcond
+
+ // 12/24 HOURS FUNCTIONS
+
+ constexpr bool
+ is_am(const hours& __h) noexcept
+ { return 0h <= __h && __h <= 11h; }
+
+ constexpr bool
+ is_pm(const hours& __h) noexcept
+ { return 12h <= __h && __h <= 23h; }
+
+ constexpr hours
+ make12(const hours& __h) noexcept
+ {
+ if (__h == 0h)
+ return 12h;
+ else if (__h > 12h)
+ return __h - 12h;
+ return __h;
+ }
+
+ constexpr hours
+ make24(const hours& __h, bool __is_pm) noexcept
+ {
+ if (!__is_pm)
+ {
+ if (__h == 12h)
+ return 0h;
+ else
+ return __h;
+ }
+ else
+ {
+ if (__h == 12h)
+ return __h;
+ else
+ return __h + 12h;
+ }
+ }
+
+#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
+ // C++20 [time.zones] Time zones
+
+ struct tzdb;
+
+ struct sys_info
+ {
+ sys_seconds begin;
+ sys_seconds end;
+ seconds offset;
+ minutes save;
+ string abbrev;
+ };
+
+ struct local_info
+ {
+ static constexpr int unique = 0;
+ static constexpr int nonexistent = 1;
+ static constexpr int ambiguous = 2;
+
+ int result;
+ sys_info first;
+ sys_info second;
+ };
+
+ class nonexistent_local_time : public runtime_error
+ {
+ public:
+ template<typename _Duration>
+ nonexistent_local_time(const local_time<_Duration>& __tp,
+ const local_info& __i)
+ : runtime_error(_S_make_what_str(__tp, __i))
+ { __glibcxx_assert(__i.result == local_info::nonexistent); }
+
+ private:
+ template<typename _Duration>
+ static string
+ _S_make_what_str(const local_time<_Duration>& __tp,
+ const local_info& __i)
+ {
+ std::ostringstream __os;
+ __os << __tp << " is in a gap between\n"
+ << local_seconds(__i.first.end.time_since_epoch())
+ + __i.first.offset << ' ' << __i.first.abbrev << " and\n"
+ << local_seconds(__i.second.begin.time_since_epoch())
+ + __i.second.offset << ' ' << __i.second.abbrev
+ << " which are both equivalent to\n"
+ << __i.first.end << " UTC";
+ return std::move(__os).str();
+ }
+ };
+
+ class ambiguous_local_time : public runtime_error
+ {
+ public:
+ template<typename _Duration>
+ ambiguous_local_time(const local_time<_Duration>& __tp,
+ const local_info& __i)
+ : runtime_error(_S_make_what_str(__tp, __i))
+ { __glibcxx_assert(__i.result == local_info::ambiguous); }
+
+ private:
+ template<typename _Duration>
+ static string
+ _S_make_what_str(const local_time<_Duration>& __tp,
+ const local_info& __i)
+ {
+ std::ostringstream __os;
+ __os << __tp << " is ambiguous. It could be\n"
+ << __tp << ' ' << __i.first.abbrev << " == "
+ << __tp - __i.first.offset << " UTC or\n"
+ << __tp << ' ' << __i.second.abbrev << " == "
+ << __tp - __i.second.offset << " UTC";
+ return std::move(__os).str();
+ }
+ };
+
+ template<typename _Duration>
+ [[noreturn]] void
+ __throw_bad_local_time(const local_time<_Duration>& __tp,
+ const local_info& __i)
+ {
+#if __cpp_exceptions
+ if (__i.result == local_info::nonexistent)
+ throw nonexistent_local_time(__tp, __i);
+ throw ambiguous_local_time(__tp, __i);
+#else
+ __builtin_abort();
+#endif
+ }
+
+ enum class choose { earliest, latest };
+
+ class time_zone
+ {
+ public:
+ time_zone(time_zone&&) = default;
+ time_zone& operator=(time_zone&&) = default;
+
+ ~time_zone();
+
+ [[nodiscard]]
+ string_view name() const noexcept { return _M_name; }
+
+ template<typename _Duration>
+ sys_info
+ get_info(const sys_time<_Duration>& __st) const
+ { return _M_get_sys_info(chrono::floor<seconds>(__st)); }
+
+ template<typename _Duration>
+ local_info
+ get_info(const local_time<_Duration>& __tp) const
+ { return _M_get_local_info(chrono::floor<seconds>(__tp)); }
+
+ template<typename _Duration>
+ sys_time<common_type_t<_Duration, seconds>>
+ to_sys(const local_time<_Duration>& __tp) const
+ {
+ local_info __info = get_info(__tp);
+
+ if (__info.result != local_info::unique)
+ __throw_bad_local_time(__tp, __info);
+
+ return sys_time<_Duration>(__tp.time_since_epoch())
+ - __info.first.offset;
+ }
+
+ template<typename _Duration>
+ sys_time<common_type_t<_Duration, seconds>>
+ to_sys(const local_time<_Duration>& __tp, choose __z) const
+ {
+ local_info __info = get_info(__tp);
+
+ if (__info.result == local_info::nonexistent)
+ return __info.first.end; // Last second of the previous sys_info.
+
+ sys_time<_Duration> __st(__tp.time_since_epoch());
+
+ if (__info.result == local_info::ambiguous && __z == choose::latest)
+ return __st - __info.second.offset; // Time in the later sys_info.
+ // else if __z == earliest, use __info.first.offset as below:
+
+ return __st - __info.first.offset;
+ }
+
+ template<typename _Duration>
+ local_time<common_type_t<_Duration, seconds>>
+ to_local(const sys_time<_Duration>& __tp) const
+ {
+ auto __d = (__tp + get_info(__tp).offset).time_since_epoch();
+ return local_time<common_type_t<_Duration, seconds>>(__d);
+ }
+
+ [[nodiscard]] friend bool
+ operator==(const time_zone& __x, const time_zone& __y) noexcept
+ { return __x._M_name == __y._M_name; }
+
+ [[nodiscard]] friend strong_ordering
+ operator<=>(const time_zone& __x, const time_zone& __y) noexcept
+ { return __x._M_name <=> __y._M_name; }
+
+ private:
+ sys_info _M_get_sys_info(sys_seconds) const;
+ local_info _M_get_local_info(local_seconds) const;
+
+ friend const tzdb& reload_tzdb();
+ friend struct tzdb;
+ friend class tzdb_list;
+
+ struct _Impl;
+
+ explicit time_zone(unique_ptr<_Impl> __p);
+ string _M_name;
+ unique_ptr<_Impl> _M_impl;
+ };
+
+ const time_zone* locate_zone(string_view __tz_name);
+ const time_zone* current_zone();
+
+ /** The list of `chrono::tzdb` objects
+ *
+ * A single object of this type is constructed by the C++ runtime,
+ * and can be accessed by calling `chrono::get_tzdb_list()`.
+ *
+ * The front of the list is the current `tzdb` object and can be accessed
+ * via `chrono::get_tzdb_list().front()` or `chrono::get_tzdb()` or
+ * `*chrono::get_tzdb_list().begin()`.
+ *
+ * The `chrono::reload_tzdb()` function will check for a newer version
+ * and if found, insert it at the front of the list.
+ *
+ * @since C++20
+ */
+ class tzdb_list
+ {
+ struct _Node;
+
+ public:
+ tzdb_list(const tzdb_list&) = delete;
+ tzdb_list& operator=(const tzdb_list&) = delete;
+
+ /** An iterator into the `tzdb_list`
+ *
+ * As a extension, in libstdc++ each `tzdb` is reference-counted
+ * and the `const_iterator` type shares ownership of the object it
+ * refers to. This ensures that a `tzdb` erased from the list will
+ * not be destroyed while there is an iterator that refers to it.
+ */
+ class const_iterator
+ {
+ public:
+ using value_type = tzdb;
+ using reference = const tzdb&;
+ using pointer = const tzdb*;
+ using difference_type = ptrdiff_t;
+ using iterator_category = forward_iterator_tag;
+
+ constexpr const_iterator() = default;
+ const_iterator(const const_iterator&) = default;
+ const_iterator(const_iterator&&) = default;
+ const_iterator& operator=(const const_iterator&) = default;
+ const_iterator& operator=(const_iterator&&) = default;
+
+ reference operator*() const noexcept;
+ pointer operator->() const noexcept { return &**this; }
+ const_iterator& operator++();
+ const_iterator operator++(int);
+
+ bool operator==(const const_iterator&) const noexcept = default;
+
+ private:
+ explicit const_iterator(const shared_ptr<_Node>&) noexcept;
+
+ friend class tzdb_list;
+
+ shared_ptr<_Node> _M_node;
+ void* _M_reserved = nullptr;
+ };
+
+ /** Access the current `tzdb` at the front of the list.
+ *
+ * This returns a reference to the same object as `chrono::get_tzdb()`.
+ *
+ * @returns A reference to the current tzdb object.
+ * @since C++20
+ */
+ const tzdb& front() const noexcept;
+
+ /** Remove the tzdb object _after_ the one the iterator refers to.
+ *
+ * Calling this function concurently with any of `front()`, `begin()`,
+ * or `end()` does not cause a data race, but in general this function
+ * is not thread-safe. The behaviour may be undefined if erasing an
+ * element from the list while another thread is calling the same
+ * function, or incrementing an iterator into the list, or accessing
+ * the element being erased (unless it is accessed through an iterator).
+ *
+ * @param __p A dereferenceable iterator.
+ * @returns An iterator the element after the one that was erased
+ * (or `end()` if there is no such element).
+ * @since C++20
+ */
+ const_iterator erase_after(const_iterator __p);
+
+ const_iterator begin() const noexcept;
+ const_iterator end() const noexcept { return {}; }
+ const_iterator cbegin() const noexcept { return begin(); }
+ const_iterator cend() const noexcept { return end(); }
+
+ private:
+ constexpr explicit tzdb_list(nullptr_t);
+
+ friend tzdb_list& get_tzdb_list();
+ friend const tzdb& get_tzdb();
+ friend const tzdb& reload_tzdb();
+ friend struct tzdb;
+ friend class leap_second;
+ friend struct time_zone::_Impl;
+ friend class time_zone_link;
+ };
+
+ class time_zone_link
+ {
+ public:
+ time_zone_link(time_zone_link&&) = default;
+ time_zone_link& operator=(time_zone_link&&) = default;
+
+ string_view name() const noexcept { return _M_name; }
+ string_view target() const noexcept { return _M_target; }
+
+ friend bool
+ operator==(const time_zone_link& __x, const time_zone_link& __y) noexcept
+ { return __x.name() == __y.name(); }
+
+ friend strong_ordering
+ operator<=>(const time_zone_link& __x, const time_zone_link& __y) noexcept
+ { return __x.name() <=> __y.name(); }
+
+ private:
+ friend const tzdb& reload_tzdb();
+ friend struct tzdb_list::_Node;
+
+ explicit time_zone_link(nullptr_t) { }
+
+ string _M_name;
+ string _M_target;
+ };
+
+ class leap_second
+ {
+ public:
+ leap_second(const leap_second&) = default;
+ leap_second& operator=(const leap_second&) = default;
+
+ [[nodiscard]]
+ constexpr sys_seconds
+ date() const noexcept
+ {
+ if (_M_s >= _M_s.zero()) [[likely]]
+ return sys_seconds(_M_s);
+ return sys_seconds(-_M_s);
+ }
+
+ [[nodiscard]]
+ constexpr seconds
+ value() const noexcept
+ {
+ if (_M_s >= _M_s.zero()) [[likely]]
+ return seconds(1);
+ return seconds(-1);
+ }
+
+ // This can be defaulted because the database will never contain two
+ // leap_second objects with the same date but different signs.
+ [[nodiscard]] friend constexpr bool
+ operator==(const leap_second&, const leap_second&) noexcept = default;
+
+ [[nodiscard]] friend constexpr strong_ordering
+ operator<=>(const leap_second& __x, const leap_second& __y) noexcept
+ { return __x.date() <=> __y.date(); }
+
+ template<typename _Duration>
+ [[nodiscard]] friend constexpr bool
+ operator==(const leap_second& __x,
+ const sys_time<_Duration>& __y) noexcept
+ { return __x.date() == __y; }
+
+ template<typename _Duration>
+ [[nodiscard]] friend constexpr bool
+ operator<(const leap_second& __x,
+ const sys_time<_Duration>& __y) noexcept
+ { return __x.date() < __y; }
+
+ template<typename _Duration>
+ [[nodiscard]] friend constexpr bool
+ operator<(const sys_time<_Duration>& __x,
+ const leap_second& __y) noexcept
+ { return __x < __y.date(); }
+
+ template<typename _Duration>
+ [[nodiscard]] friend constexpr bool
+ operator>(const leap_second& __x,
+ const sys_time<_Duration>& __y) noexcept
+ { return __y < __x.date(); }
+
+ template<typename _Duration>
+ [[nodiscard]] friend constexpr bool
+ operator>(const sys_time<_Duration>& __x,
+ const leap_second& __y) noexcept
+ { return __y.date() < __x; }
+
+ template<typename _Duration>
+ [[nodiscard]] friend constexpr bool
+ operator<=(const leap_second& __x,
+ const sys_time<_Duration>& __y) noexcept
+ { return !(__y < __x.date()); }
+
+ template<typename _Duration>
+ [[nodiscard]] friend constexpr bool
+ operator<=(const sys_time<_Duration>& __x,
+ const leap_second& __y) noexcept
+ { return !(__y.date() < __x); }
+
+ template<typename _Duration>
+ [[nodiscard]] friend constexpr bool
+ operator>=(const leap_second& __x,
+ const sys_time<_Duration>& __y) noexcept
+ { return !(__x.date() < __y); }
+
+ template<typename _Duration>
+ [[nodiscard]] friend constexpr bool
+ operator>=(const sys_time<_Duration>& __x,
+ const leap_second& __y) noexcept
+ { return !(__x < __y.date()); }
+
+ template<three_way_comparable_with<seconds> _Duration>
+ [[nodiscard]] friend constexpr auto
+ operator<=>(const leap_second& __x,
+ const sys_time<_Duration>& __y) noexcept
+ { return __x.date() <=> __y; }
+
+ private:
+ explicit leap_second(seconds::rep __s) : _M_s(__s) { }
+
+ friend struct tzdb_list::_Node;
+
+ friend const tzdb& reload_tzdb();
+
+ template<typename _Duration>
+ friend leap_second_info
+ get_leap_second_info(const utc_time<_Duration>&);
+
+ seconds _M_s; // == date().time_since_epoch() * value().count()
+ };
+
+ template<class _Tp> struct zoned_traits { };
+
+ template<>
+ struct zoned_traits<const time_zone*>
+ {
+ static const time_zone*
+ default_zone()
+ { return std::chrono::locate_zone("UTC"); }
+
+ static const time_zone*
+ locate_zone(string_view __name)
+ { return std::chrono::locate_zone(__name); }
+ };
+
+ struct tzdb
+ {
+ string version;
+ _GLIBCXX_STD_C::vector<time_zone> zones;
+ _GLIBCXX_STD_C::vector<time_zone_link> links;
+ _GLIBCXX_STD_C::vector<leap_second> leap_seconds;
+
+ const time_zone*
+ locate_zone(string_view __tz_name) const;
+
+ const time_zone*
+ current_zone() const;
+
+ private:
+ friend const tzdb& reload_tzdb();
+ friend class time_zone;
+ friend struct tzdb_list::_Node;
+ };
+
+ tzdb_list& get_tzdb_list();
+ const tzdb& get_tzdb();
+
+ const tzdb& reload_tzdb();
+ string remote_version();
+
+ template<typename _Duration, typename _TimeZonePtr = const time_zone*>
+ class zoned_time
+ {
+ static_assert(__is_duration_v<_Duration>);
+
+ using _Traits = zoned_traits<_TimeZonePtr>;
+
+ // Every constructor that accepts a string_view as its first parameter
+ // does not participate in class template argument deduction.
+ using string_view = type_identity_t<std::string_view>;
+
+ public:
+ using duration = common_type_t<_Duration, seconds>;
+
+ zoned_time() requires requires { _Traits::default_zone(); }
+ { }
+
+ zoned_time(const zoned_time&) = default;
+ zoned_time& operator=(const zoned_time&) = default;
+
+ zoned_time(const sys_time<_Duration>& __st)
+ requires requires { _Traits::default_zone(); }
+ : _M_tp(__st)
+ { }
+
+ explicit
+ zoned_time(_TimeZonePtr __z) : _M_zone(std::move(__z)) { }
+
+ explicit
+ zoned_time(string_view __name)
+ requires requires {
+ _TimeZonePtr{_Traits::locate_zone(std::string_view{})};
+ }
+ : _M_zone(_Traits::locate_zone(__name))
+ { }
+
+ template<typename _Duration2>
+ zoned_time(const zoned_time<_Duration2, _TimeZonePtr>& __zt)
+ requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+ : _M_zone(__zt._M_zone), _M_tp(__zt._M_tp)
+ { }
+
+ zoned_time(_TimeZonePtr __z, const sys_time<_Duration>& __st)
+ : _M_zone(std::move(__z)), _M_tp(__st)
+ { }
+
+ zoned_time(string_view __name, const sys_time<_Duration>& __st)
+ : zoned_time(_Traits::locate_zone(__name), __st)
+ { }
+
+ zoned_time(_TimeZonePtr __z, const local_time<_Duration>& __tp)
+ requires requires {
+ { __z->to_sys(__tp) } -> convertible_to<sys_time<_Duration>>;
+ }
+ : _M_zone(std::move(__z)), _M_tp(_M_zone->to_sys(__tp))
+ { }
+
+ zoned_time(string_view __name, const local_time<_Duration>& __tp)
+ requires requires (_TimeZonePtr __z) {
+ { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
+ { __z->to_sys(__tp) } -> convertible_to<sys_time<_Duration>>;
+ }
+ : zoned_time(_Traits::locate_zone(__name), __tp)
+ { }
+
+ zoned_time(_TimeZonePtr __z, const local_time<_Duration>& __tp,
+ choose __c)
+ requires requires {
+ { __z->to_sys(__tp, __c) } -> convertible_to<sys_time<_Duration>>;
+ }
+ : _M_zone(std::move(__z)), _M_tp(_M_zone->to_sys(__tp, __c))
+ { }
+
+ zoned_time(string_view __name, const local_time<_Duration>& __tp,
+ choose __c)
+ requires requires (_TimeZonePtr __z) {
+ { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
+ { __z->to_sys(__tp, __c) } -> convertible_to<sys_time<_Duration>>;
+ }
+ : _M_zone(_Traits::locate_zone(__name)),
+ _M_tp(_M_zone->to_sys(__tp, __c))
+ { }
+
+ template<typename _Duration2, typename _TimeZonePtr2>
+ zoned_time(_TimeZonePtr __z,
+ const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
+ requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+ : _M_zone(__z), _M_tp(__zt._M_tp)
+ { }
+
+ template<typename _Duration2, typename _TimeZonePtr2>
+ zoned_time(_TimeZonePtr __z,
+ const zoned_time<_Duration2, _TimeZonePtr2>& __zt,
+ choose)
+ requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+ : _M_zone(__z), _M_tp(__zt._M_tp)
+ { }
+
+ template<typename _Duration2, typename _TimeZonePtr2>
+ zoned_time(string_view __name,
+ const zoned_time<_Duration2, _TimeZonePtr2>& __zt)
+ requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+ && requires {
+ { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
+ }
+ : _M_zone(_Traits::locate_zone(__name)), _M_tp(__zt._M_tp)
+ { }
+
+ template<typename _Duration2, typename _TimeZonePtr2>
+ zoned_time(string_view __name,
+ const zoned_time<_Duration2, _TimeZonePtr2>& __zt,
+ choose)
+ requires is_convertible_v<sys_time<_Duration2>, sys_time<_Duration>>
+ && requires {
+ { _Traits::locate_zone(__name) } -> convertible_to<_TimeZonePtr>;
+ }
+ : _M_zone(_Traits::locate_zone(__name)), _M_tp(__zt._M_tp)
+ { }
+
+ zoned_time&
+ operator=(const sys_time<_Duration>& __st)
+ {
+ _M_tp = __st;
+ return *this;
+ }
+
+ zoned_time&
+ operator=(const local_time<_Duration>& __lt)
+ {
+ _M_tp = _M_zone->to_sys(__lt);
+ return *this;
+ }
+
+ [[nodiscard]]
+ operator sys_time<duration>() const { return _M_tp; }
+
+ [[nodiscard]]
+ explicit operator local_time<duration>() const
+ { return get_local_time(); }
+
+ [[nodiscard]]
+ _TimeZonePtr
+ get_time_zone() const
+ { return _M_zone; }
+
+ [[nodiscard]]
+ local_time<duration>
+ get_local_time() const
+ { return _M_zone->to_local(_M_tp); }
+
+ [[nodiscard]]
+ sys_time<duration>
+ get_sys_time() const
+ { return _M_tp; }
+
+ [[nodiscard]]
+ sys_info
+ get_info() const
+ { return _M_zone->get_info(_M_tp); }
+
+ [[nodiscard]] friend bool
+ operator==(const zoned_time&, const zoned_time&) = default;
+
+ private:
+ _TimeZonePtr _M_zone{ _Traits::default_zone() };
+ sys_time<duration> _M_tp{};
+
+ template<typename _Duration2, typename _TimeZonePtr2>
+ friend class zoned_time;
+ };
+
+ zoned_time() -> zoned_time<seconds>;
+
+ template<typename _Duration>
+ zoned_time(sys_time<_Duration>)
+ -> zoned_time<common_type_t<_Duration, seconds>>;
+
+ /// @cond undocumented
+ template<typename _TimeZonePtrOrName>
+ using __time_zone_representation
+ = __conditional_t<is_convertible_v<_TimeZonePtrOrName, string_view>,
+ const time_zone*,
+ remove_cvref_t<_TimeZonePtrOrName>>;
+ /// @endcond
+
+ template<typename _TimeZonePtrOrName>
+ zoned_time(_TimeZonePtrOrName&&)
+ -> zoned_time<seconds, __time_zone_representation<_TimeZonePtrOrName>>;
+
+ template<typename _TimeZonePtrOrName, typename _Duration>
+ zoned_time(_TimeZonePtrOrName&&, sys_time<_Duration>)
+ -> zoned_time<common_type_t<_Duration, seconds>,
+ __time_zone_representation<_TimeZonePtrOrName>>;
+
+ template<typename _TimeZonePtrOrName, typename _Duration>
+ zoned_time(_TimeZonePtrOrName&&, local_time<_Duration>,
+ choose = choose::earliest)
+ -> zoned_time<common_type_t<_Duration, seconds>,
+ __time_zone_representation<_TimeZonePtrOrName>>;
+
+ template<typename _Duration, typename _TimeZonePtrOrName,
+ typename _TimeZonePtr2>
+ zoned_time(_TimeZonePtrOrName&&, zoned_time<_Duration, _TimeZonePtr2>,
+ choose = choose::earliest)
+ -> zoned_time<common_type_t<_Duration, seconds>,
+ __time_zone_representation<_TimeZonePtrOrName>>;
+
+ template<typename _Dur1, typename _TZPtr1, typename _Dur2, typename _TZPtr2>
+ [[nodiscard]]
+ inline bool
+ operator==(const zoned_time<_Dur1, _TZPtr1>& __x,
+ const zoned_time<_Dur2, _TZPtr2>& __y)
+ {
+ return __x.get_time_zone() == __y.get_time_zone()
+ && __x.get_sys_time() == __y.get_sys_time();
+ }
+
+ using zoned_seconds = zoned_time<seconds>;
+#endif // _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
+
+namespace __detail
+{
+ inline leap_second_info
+ __get_leap_second_info(sys_seconds __ss, bool __is_utc)
+ {
+ if (__ss < sys_seconds{}) [[unlikely]]
+ return {};
+
+ const seconds::rep __leaps[] {
+ 78796800, // 1 Jul 1972
+ 94694400, // 1 Jan 1973
+ 126230400, // 1 Jan 1974
+ 157766400, // 1 Jan 1975
+ 189302400, // 1 Jan 1976
+ 220924800, // 1 Jan 1977
+ 252460800, // 1 Jan 1978
+ 283996800, // 1 Jan 1979
+ 315532800, // 1 Jan 1980
+ 362793600, // 1 Jul 1981
+ 394329600, // 1 Jul 1982
+ 425865600, // 1 Jul 1983
+ 489024000, // 1 Jul 1985
+ 567993600, // 1 Jan 1988
+ 631152000, // 1 Jan 1990
+ 662688000, // 1 Jan 1991
+ 709948800, // 1 Jul 1992
+ 741484800, // 1 Jul 1993
+ 773020800, // 1 Jul 1994
+ 820454400, // 1 Jan 1996
+ 867715200, // 1 Jul 1997
+ 915148800, // 1 Jan 1999
+ 1136073600, // 1 Jan 2006
+ 1230768000, // 1 Jan 2009
+ 1341100800, // 1 Jul 2012
+ 1435708800, // 1 Jul 2015
+ 1483228800, // 1 Jan 2017
+ };
+ // The list above is known to be valid until (at least) this date
+ // and only contains positive leap seconds.
+ const sys_seconds __expires(1703721600s); // 2023-12-28 00:00:00 UTC
+
+#if _GLIBCXX_USE_CXX11_ABI || ! _GLIBCXX_USE_DUAL_ABI
+ if (__ss > __expires)
+ {
+ // Use updated leap_seconds from tzdb.
+ size_t __n = std::size(__leaps);
+
+ auto __db = get_tzdb_list().begin();
+ auto __first = __db->leap_seconds.begin() + __n;
+ auto __last = __db->leap_seconds.end();
+ auto __pos = std::upper_bound(__first, __last, __ss);
+ seconds __elapsed(__n);
+ for (auto __i = __first; __i != __pos; ++__i)
+ __elapsed += __i->value();
+
+ if (__is_utc)
+ {
+ // Convert utc_time to sys_time:
+ __ss -= __elapsed;
+ // See if that sys_time is before (or during) previous leap sec:
+ if (__pos != __first && __ss < __pos[-1])
+ {
+ if ((__ss + 1s) >= __pos[-1])
+ return {true, __elapsed};
+ __elapsed -= __pos[-1].value();
+ }
+ }
+ return {false, __elapsed};
+ }
+ else
+#endif
+ {
+ seconds::rep __s = __ss.time_since_epoch().count();
+ const seconds::rep* __first = std::begin(__leaps);
+ const seconds::rep* __last = std::end(__leaps);
+
+ // Don't bother searching the list if we're after the last one.
+ if (__s > (__last[-1] + (__last - __first) + 1))
+ return { false, seconds(__last - __first) };
+
+ auto __pos = std::upper_bound(__first, __last, __s);
+ seconds __elapsed{__pos - __first};
+ if (__is_utc)
+ {
+ // Convert utc_time to sys_time:
+ __s -= __elapsed.count();
+ // See if that sys_time is before (or during) previous leap sec:
+ if (__pos != __first && __s < __pos[-1])
+ {
+ if ((__s + 1) >= __pos[-1])
+ return {true, __elapsed};
+ --__elapsed;
+ }
+ }
+ return {false, __elapsed};
+ }
+ }
+} // namespace __detail
+
+ template<typename _Duration>
+ [[nodiscard]]
+ inline leap_second_info
+ get_leap_second_info(const utc_time<_Duration>& __ut)
+ {
+ auto __s = chrono::duration_cast<seconds>(__ut.time_since_epoch());
+ return __detail::__get_leap_second_info(sys_seconds(__s), true);
+ }
+
+ template<typename _Duration>
+ [[nodiscard]]
+ inline utc_time<common_type_t<_Duration, seconds>>
+ utc_clock::from_sys(const sys_time<_Duration>& __t)
+ {
+ using _CDur = common_type_t<_Duration, seconds>;
+ auto __s = chrono::time_point_cast<seconds>(__t);
+ const auto __li = __detail::__get_leap_second_info(__s, false);
+ return utc_time<_CDur>{__t.time_since_epoch()} + __li.elapsed;
+ }
+
+ /// @} group chrono
+#endif // C++20
+ } // namespace chrono
+
+#if __cplusplus >= 202002L
+ inline namespace literals
+ {
+ inline namespace chrono_literals
+ {
+ /// @addtogroup chrono
+ /// @{
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wliteral-suffix"
+ /// Literal suffix for creating chrono::day objects.
+ /// @since C++20
+ constexpr chrono::day
+ operator""d(unsigned long long __d) noexcept
+ { return chrono::day{static_cast<unsigned>(__d)}; }
+
+ /// Literal suffix for creating chrono::year objects.
+ /// @since C++20
+ constexpr chrono::year
+ operator""y(unsigned long long __y) noexcept
+ { return chrono::year{static_cast<int>(__y)}; }
+#pragma GCC diagnostic pop
+ /// @}
+ } // inline namespace chrono_literals
+ } // inline namespace literals
+#endif // C++20
+
+_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
-#endif //_GLIBCXX_USE_C99_STDINT_TR1
+#if __cplusplus >= 202002L
+# include <bits/chrono_io.h>
+#endif
#endif // C++11