164 lines · c
1// -*- C++ -*-2//===----------------------------------------------------------------------===//3//4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP___CHRONO_UTC_CLOCK_H11#define _LIBCPP___CHRONO_UTC_CLOCK_H12 13#include <version>14// Enable the contents of the header only when libc++ was built with experimental features enabled.15#if _LIBCPP_HAS_EXPERIMENTAL_TZDB16 17# include <__chrono/duration.h>18# include <__chrono/leap_second.h>19# include <__chrono/system_clock.h>20# include <__chrono/time_point.h>21# include <__chrono/tzdb.h>22# include <__chrono/tzdb_list.h>23# include <__config>24# include <__type_traits/common_type.h>25 26# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)27# pragma GCC system_header28# endif29 30_LIBCPP_BEGIN_NAMESPACE_STD31 32# if _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM && _LIBCPP_HAS_LOCALIZATION33 34namespace chrono {35 36class utc_clock;37 38template <class _Duration>39using utc_time = time_point<utc_clock, _Duration>;40using utc_seconds = utc_time<seconds>;41 42class utc_clock {43public:44 using rep = system_clock::rep;45 using period = system_clock::period;46 using duration = chrono::duration<rep, period>;47 using time_point = chrono::time_point<utc_clock>;48 static constexpr bool is_steady = false; // The system_clock is not steady.49 50 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static time_point now() { return from_sys(system_clock::now()); }51 52 template <class _Duration>53 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static sys_time<common_type_t<_Duration, seconds>>54 to_sys(const utc_time<_Duration>& __time);55 56 template <class _Duration>57 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static utc_time<common_type_t<_Duration, seconds>>58 from_sys(const sys_time<_Duration>& __time) {59 using _Rp = utc_time<common_type_t<_Duration, seconds>>;60 // TODO TZDB investigate optimizations.61 //62 // The leap second database stores all transitions, this mean to calculate63 // the current number of leap seconds the code needs to iterate over all64 // leap seconds to accumulate the sum. Then the sum can be used to determine65 // the sys_time. Accessing the database involves acquiring a mutex.66 //67 // The historic entries in the database are immutable. Hard-coding these68 // values in a table would allow:69 // - To store the sum, allowing a binary search on the data.70 // - Avoid acquiring a mutex.71 // The disadvantage are:72 // - A slightly larger code size.73 //74 // There are two optimization directions75 // - hard-code the database and do a linear search for future entries. This76 // search can start at the back, and should probably contain very few77 // entries. (Adding leap seconds is quite rare and new release of libc++78 // can add the new entries; they are announced half a year before they are79 // added.)80 // - During parsing the leap seconds store an additional database in the81 // dylib with the list of the sum of the leap seconds. In that case there82 // can be a private function __get_utc_to_sys_table that returns the83 // table.84 //85 // Note for to_sys there are no optimizations to be done; it uses86 // get_leap_second_info. The function get_leap_second_info could benefit87 // from optimizations as described above; again both options apply.88 89 // Both UTC and the system clock use the same epoch. The Standard90 // specifies from 1970-01-01 even when UTC starts at91 // 1972-01-01 00:00:10 TAI. So when the sys_time is before epoch we can be92 // sure there both clocks return the same value.93 94 const tzdb& __tzdb = chrono::get_tzdb();95 _Rp __result{__time.time_since_epoch()};96 for (const auto& __leap_second : __tzdb.leap_seconds) {97 if (__leap_second > __time)98 return __result;99 100 __result += __leap_second.value();101 }102 return __result;103 }104};105 106struct leap_second_info {107 bool is_leap_second;108 seconds elapsed;109};110 111template <class _Duration>112[[nodiscard]] _LIBCPP_HIDE_FROM_ABI leap_second_info get_leap_second_info(const utc_time<_Duration>& __time) {113 const tzdb& __tzdb = chrono::get_tzdb();114 if (__tzdb.leap_seconds.empty()) [[unlikely]]115 return {false, chrono::seconds{0}};116 117 sys_seconds __sys{chrono::floor<seconds>(__time).time_since_epoch()};118 seconds __elapsed{0};119 for (const auto& __leap_second : __tzdb.leap_seconds) {120 if (__sys == __leap_second.date() + __elapsed)121 // A time point may only be a leap second during a positive leap second122 // insertion, since time points that occur during a (theoretical)123 // negative leap second don't exist.124 return {__leap_second.value() > 0s, __elapsed + __leap_second.value()};125 126 if (__sys < __leap_second.date() + __elapsed)127 return {false, __elapsed};128 129 __elapsed += __leap_second.value();130 }131 132 return {false, __elapsed};133}134 135template <class _Duration>136[[nodiscard]] _LIBCPP_HIDE_FROM_ABI sys_time<common_type_t<_Duration, seconds>>137utc_clock::to_sys(const utc_time<_Duration>& __time) {138 using _Dp = common_type_t<_Duration, seconds>;139 leap_second_info __info = chrono::get_leap_second_info(__time);140 141 // [time.clock.utc.members]/2142 // Returns: A sys_time t, such that from_sys(t) == u if such a mapping143 // exists. Otherwise u represents a time_point during a positive leap144 // second insertion, the conversion counts that leap second as not145 // inserted, and the last representable value of sys_time prior to the146 // insertion of the leap second is returned.147 sys_time<common_type_t<_Duration, seconds>> __result{__time.time_since_epoch() - __info.elapsed};148 if (__info.is_leap_second)149 return chrono::floor<seconds>(__result) + chrono::seconds{1} - _Dp{1};150 151 return __result;152}153 154} // namespace chrono155 156# endif // _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM &&157 // _LIBCPP_HAS_LOCALIZATION158 159_LIBCPP_END_NAMESPACE_STD160 161#endif // _LIBCPP_HAS_EXPERIMENTAL_TZDB162 163#endif // _LIBCPP___CHRONO_UTC_CLOCK_H164