@nxtedition/rocksdb 15.2.2 → 15.2.4

package/deps/abseil-cpp/absl/time/internal/cctz/src/time_zone_info.h

@@ -1,128 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   https://www.apache.org/licenses/LICENSE-2.0
-//
-//   Unless required by applicable law or agreed to in writing, software
-//   distributed under the License is distributed on an "AS IS" BASIS,
-//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//   See the License for the specific language governing permissions and
-//   limitations under the License.
-
-#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
-#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
-
-#include <atomic>
-#include <cstddef>
-#include <cstdint>
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "absl/base/config.h"
-#include "absl/time/internal/cctz/include/cctz/civil_time.h"
-#include "absl/time/internal/cctz/include/cctz/time_zone.h"
-#include "absl/time/internal/cctz/include/cctz/zone_info_source.h"
-#include "absl/time/internal/cctz/src/time_zone_if.h"
-#include "absl/time/internal/cctz/src/tzfile.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
-
-// A transition to a new UTC offset.
-struct Transition {
-  std::int_least64_t unix_time;   // the instant of this transition
-  std::uint_least8_t type_index;  // index of the transition type
-  civil_second civil_sec;         // local civil time of transition
-  civil_second prev_civil_sec;    // local civil time one second earlier
-
-  struct ByUnixTime {
-    inline bool operator()(const Transition& lhs, const Transition& rhs) const {
-      return lhs.unix_time < rhs.unix_time;
-    }
-  };
-  struct ByCivilTime {
-    inline bool operator()(const Transition& lhs, const Transition& rhs) const {
-      return lhs.civil_sec < rhs.civil_sec;
-    }
-  };
-};
-
-// The characteristics of a particular transition.
-struct TransitionType {
-  std::int_least32_t utc_offset;  // the new prevailing UTC offset
-  civil_second civil_max;         // max convertible civil time for offset
-  civil_second civil_min;         // min convertible civil time for offset
-  bool is_dst;                    // did we move into daylight-saving time
-  std::uint_least8_t abbr_index;  // index of the new abbreviation
-};
-
-// A time zone backed by the IANA Time Zone Database (zoneinfo).
-class TimeZoneInfo : public TimeZoneIf {
- public:
-  // Factories.
-  static std::unique_ptr<TimeZoneInfo> UTC();  // never fails
-  static std::unique_ptr<TimeZoneInfo> Make(const std::string& name);
-
-  // TimeZoneIf implementations.
-  time_zone::absolute_lookup BreakTime(
-      const time_point<seconds>& tp) const override;
-  time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
-  bool NextTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const override;
-  bool PrevTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const override;
-  std::string Version() const override;
-  std::string Description() const override;
-
- private:
-  TimeZoneInfo() = default;
-  TimeZoneInfo(const TimeZoneInfo&) = delete;
-  TimeZoneInfo& operator=(const TimeZoneInfo&) = delete;
-
-  bool GetTransitionType(std::int_fast32_t utc_offset, bool is_dst,
-                         const std::string& abbr, std::uint_least8_t* index);
-  bool EquivTransitions(std::uint_fast8_t tt1_index,
-                        std::uint_fast8_t tt2_index) const;
-  bool ExtendTransitions();
-
-  bool ResetToBuiltinUTC(const seconds& offset);
-  bool Load(const std::string& name);
-  bool Load(ZoneInfoSource* zip);
-
-  // Helpers for BreakTime() and MakeTime().
-  time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
-                                       const TransitionType& tt) const;
-  time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
-                                       const Transition& tr) const;
-  time_zone::civil_lookup TimeLocal(const civil_second& cs,
-                                    year_t c4_shift) const;
-
-  std::vector<Transition> transitions_;  // ordered by unix_time and civil_sec
-  std::vector<TransitionType> transition_types_;  // distinct transition types
-  std::uint_fast8_t default_transition_type_;     // for before first transition
-  std::string abbreviations_;  // all the NUL-terminated abbreviations
-
-  std::string version_;      // the tzdata version if available
-  std::string future_spec_;  // for after the last zic transition
-  bool extended_;            // future_spec_ was used to generate transitions
-  year_t last_year_;         // the final year of the generated transitions
-
-  // We remember the transitions found during the last BreakTime() and
-  // MakeTime() calls. If the next request is for the same transition we
-  // will avoid re-searching.
-  mutable std::atomic<std::size_t> local_time_hint_ = {};  // BreakTime() hint
-  mutable std::atomic<std::size_t> time_local_hint_ = {};  // MakeTime() hint
-};
-
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_

package/deps/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.cc

@@ -1,333 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   https://www.apache.org/licenses/LICENSE-2.0
-//
-//   Unless required by applicable law or agreed to in writing, software
-//   distributed under the License is distributed on an "AS IS" BASIS,
-//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//   See the License for the specific language governing permissions and
-//   limitations under the License.
-
-#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_WIN32)
-#define _CRT_SECURE_NO_WARNINGS 1
-#endif
-
-#include "absl/time/internal/cctz/src/time_zone_libc.h"
-
-#include <chrono>
-#include <ctime>
-#include <limits>
-#include <utility>
-
-#include "absl/base/config.h"
-#include "absl/time/internal/cctz/include/cctz/civil_time.h"
-#include "absl/time/internal/cctz/include/cctz/time_zone.h"
-
-#if defined(_AIX)
-extern "C" {
-extern long altzone;
-}
-#endif
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
-
-namespace {
-
-#if defined(_WIN32) || defined(_WIN64)
-// Uses the globals: '_timezone', '_dstbias' and '_tzname'.
-auto tm_gmtoff(const std::tm& tm) -> decltype(_timezone + _dstbias) {
-  const bool is_dst = tm.tm_isdst > 0;
-  return _timezone + (is_dst ? _dstbias : 0);
-}
-auto tm_zone(const std::tm& tm) -> decltype(_tzname[0]) {
-  const bool is_dst = tm.tm_isdst > 0;
-  return _tzname[is_dst];
-}
-#elif defined(__sun) || defined(_AIX)
-// Uses the globals: 'timezone', 'altzone' and 'tzname'.
-auto tm_gmtoff(const std::tm& tm) -> decltype(timezone) {
-  const bool is_dst = tm.tm_isdst > 0;
-  return is_dst ? altzone : timezone;
-}
-auto tm_zone(const std::tm& tm) -> decltype(tzname[0]) {
-  const bool is_dst = tm.tm_isdst > 0;
-  return tzname[is_dst];
-}
-#elif defined(__native_client__) || defined(__myriad2__) || \
-    defined(__EMSCRIPTEN__)
-// Uses the globals: '_timezone' and 'tzname'.
-auto tm_gmtoff(const std::tm& tm) -> decltype(_timezone + 0) {
-  const bool is_dst = tm.tm_isdst > 0;
-  return _timezone + (is_dst ? 60 * 60 : 0);
-}
-auto tm_zone(const std::tm& tm) -> decltype(tzname[0]) {
-  const bool is_dst = tm.tm_isdst > 0;
-  return tzname[is_dst];
-}
-#elif defined(__VXWORKS__)
-// Uses the globals: 'timezone' and 'tzname'.
-auto tm_gmtoff(const std::tm& tm) -> decltype(timezone + 0) {
-  const bool is_dst = tm.tm_isdst > 0;
-  return timezone + (is_dst ? 60 * 60 : 0);
-}
-auto tm_zone(const std::tm& tm) -> decltype(tzname[0]) {
-  const bool is_dst = tm.tm_isdst > 0;
-  return tzname[is_dst];
-}
-#else
-// Adapt to different spellings of the struct std::tm extension fields.
-#if defined(tm_gmtoff)
-auto tm_gmtoff(const std::tm& tm) -> decltype(tm.tm_gmtoff) {
-  return tm.tm_gmtoff;
-}
-#elif defined(__tm_gmtoff)
-auto tm_gmtoff(const std::tm& tm) -> decltype(tm.__tm_gmtoff) {
-  return tm.__tm_gmtoff;
-}
-#else
-template <typename T>
-auto tm_gmtoff(const T& tm) -> decltype(tm.tm_gmtoff) {
-  return tm.tm_gmtoff;
-}
-template <typename T>
-auto tm_gmtoff(const T& tm) -> decltype(tm.__tm_gmtoff) {
-  return tm.__tm_gmtoff;
-}
-#endif  // tm_gmtoff
-#if defined(tm_zone)
-auto tm_zone(const std::tm& tm) -> decltype(tm.tm_zone) { return tm.tm_zone; }
-#elif defined(__tm_zone)
-auto tm_zone(const std::tm& tm) -> decltype(tm.__tm_zone) {
-  return tm.__tm_zone;
-}
-#else
-template <typename T>
-auto tm_zone(const T& tm) -> decltype(tm.tm_zone) {
-  return tm.tm_zone;
-}
-template <typename T>
-auto tm_zone(const T& tm) -> decltype(tm.__tm_zone) {
-  return tm.__tm_zone;
-}
-#endif  // tm_zone
-#endif
-using tm_gmtoff_t = decltype(tm_gmtoff(std::tm{}));
-
-inline std::tm* gm_time(const std::time_t* timep, std::tm* result) {
-#if defined(_WIN32) || defined(_WIN64)
-  return gmtime_s(result, timep) ? nullptr : result;
-#else
-  return gmtime_r(timep, result);
-#endif
-}
-
-inline std::tm* local_time(const std::time_t* timep, std::tm* result) {
-#if defined(_WIN32) || defined(_WIN64)
-  return localtime_s(result, timep) ? nullptr : result;
-#else
-  return localtime_r(timep, result);
-#endif
-}
-
-// Converts a civil second and "dst" flag into a time_t and a struct tm.
-// Returns false if time_t cannot represent the requested civil second.
-// Caller must have already checked that cs.year() will fit into a tm_year.
-bool make_time(const civil_second& cs, int is_dst, std::time_t* t,
-               std::tm* tm) {
-  tm->tm_year = static_cast<int>(cs.year() - year_t{1900});
-  tm->tm_mon = cs.month() - 1;
-  tm->tm_mday = cs.day();
-  tm->tm_hour = cs.hour();
-  tm->tm_min = cs.minute();
-  tm->tm_sec = cs.second();
-  tm->tm_isdst = is_dst;
-  *t = std::mktime(tm);
-  if (*t == std::time_t{-1}) {
-    std::tm tm2;
-    const std::tm* tmp = local_time(t, &tm2);
-    if (tmp == nullptr || tmp->tm_year != tm->tm_year ||
-        tmp->tm_mon != tm->tm_mon || tmp->tm_mday != tm->tm_mday ||
-        tmp->tm_hour != tm->tm_hour || tmp->tm_min != tm->tm_min ||
-        tmp->tm_sec != tm->tm_sec) {
-      // A true error (not just one second before the epoch).
-      return false;
-    }
-  }
-  return true;
-}
-
-// Find the least time_t in [lo:hi] where local time matches offset, given:
-// (1) lo doesn't match, (2) hi does, and (3) there is only one transition.
-std::time_t find_trans(std::time_t lo, std::time_t hi, tm_gmtoff_t offset) {
-  std::tm tm;
-  while (lo + 1 != hi) {
-    const std::time_t mid = lo + (hi - lo) / 2;
-    std::tm* tmp = local_time(&mid, &tm);
-    if (tmp != nullptr) {
-      if (tm_gmtoff(*tmp) == offset) {
-        hi = mid;
-      } else {
-        lo = mid;
-      }
-    } else {
-      // If std::tm cannot hold some result we resort to a linear search,
-      // ignoring all failed conversions.  Slow, but never really happens.
-      while (++lo != hi) {
-        tmp = local_time(&lo, &tm);
-        if (tmp != nullptr) {
-          if (tm_gmtoff(*tmp) == offset) break;
-        }
-      }
-      return lo;
-    }
-  }
-  return hi;
-}
-
-}  // namespace
-
-std::unique_ptr<TimeZoneLibC> TimeZoneLibC::Make(const std::string& name) {
-  return std::unique_ptr<TimeZoneLibC>(new TimeZoneLibC(name));
-}
-
-time_zone::absolute_lookup TimeZoneLibC::BreakTime(
-    const time_point<seconds>& tp) const {
-  time_zone::absolute_lookup al;
-  al.offset = 0;
-  al.is_dst = false;
-  al.abbr = "-00";
-
-  const std::int_fast64_t s = ToUnixSeconds(tp);
-
-  // If std::time_t cannot hold the input we saturate the output.
-  if (s < std::numeric_limits<std::time_t>::min()) {
-    al.cs = civil_second::min();
-    return al;
-  }
-  if (s > std::numeric_limits<std::time_t>::max()) {
-    al.cs = civil_second::max();
-    return al;
-  }
-
-  const std::time_t t = static_cast<std::time_t>(s);
-  std::tm tm;
-  std::tm* tmp = local_ ? local_time(&t, &tm) : gm_time(&t, &tm);
-
-  // If std::tm cannot hold the result we saturate the output.
-  if (tmp == nullptr) {
-    al.cs = (s < 0) ? civil_second::min() : civil_second::max();
-    return al;
-  }
-
-  const year_t year = tmp->tm_year + year_t{1900};
-  al.cs = civil_second(year, tmp->tm_mon + 1, tmp->tm_mday, tmp->tm_hour,
-                       tmp->tm_min, tmp->tm_sec);
-  al.offset = static_cast<int>(tm_gmtoff(*tmp));
-  al.abbr = local_ ? tm_zone(*tmp) : "UTC";  // as expected by cctz
-  al.is_dst = tmp->tm_isdst > 0;
-  return al;
-}
-
-time_zone::civil_lookup TimeZoneLibC::MakeTime(const civil_second& cs) const {
-  if (!local_) {
-    // If time_point<seconds> cannot hold the result we saturate.
-    static const civil_second min_tp_cs =
-        civil_second() + ToUnixSeconds(time_point<seconds>::min());
-    static const civil_second max_tp_cs =
-        civil_second() + ToUnixSeconds(time_point<seconds>::max());
-    const time_point<seconds> tp = (cs < min_tp_cs) ? time_point<seconds>::min()
-                                   : (cs > max_tp_cs)
-                                       ? time_point<seconds>::max()
-                                       : FromUnixSeconds(cs - civil_second());
-    return {time_zone::civil_lookup::UNIQUE, tp, tp, tp};
-  }
-
-  // If tm_year cannot hold the requested year we saturate the result.
-  if (cs.year() < 0) {
-    if (cs.year() < std::numeric_limits<int>::min() + year_t{1900}) {
-      const time_point<seconds> tp = time_point<seconds>::min();
-      return {time_zone::civil_lookup::UNIQUE, tp, tp, tp};
-    }
-  } else {
-    if (cs.year() - year_t{1900} > std::numeric_limits<int>::max()) {
-      const time_point<seconds> tp = time_point<seconds>::max();
-      return {time_zone::civil_lookup::UNIQUE, tp, tp, tp};
-    }
-  }
-
-  // We probe with "is_dst" values of 0 and 1 to try to distinguish unique
-  // civil seconds from skipped or repeated ones.  This is not always possible
-  // however, as the "dst" flag does not change over some offset transitions.
-  // We are also subject to the vagaries of mktime() implementations. For
-  // example, some implementations treat "tm_isdst" as a demand (useless),
-  // and some as a disambiguator (useful).
-  std::time_t t0, t1;
-  std::tm tm0, tm1;
-  if (make_time(cs, 0, &t0, &tm0) && make_time(cs, 1, &t1, &tm1)) {
-    if (tm0.tm_isdst == tm1.tm_isdst) {
-      // The civil time was singular (pre == trans == post).
-      const time_point<seconds> tp = FromUnixSeconds(tm0.tm_isdst ? t1 : t0);
-      return {time_zone::civil_lookup::UNIQUE, tp, tp, tp};
-    }
-
-    tm_gmtoff_t offset = tm_gmtoff(tm0);
-    if (t0 < t1) {  // negative DST
-      std::swap(t0, t1);
-      offset = tm_gmtoff(tm1);
-    }
-
-    const std::time_t tt = find_trans(t1, t0, offset);
-    const time_point<seconds> trans = FromUnixSeconds(tt);
-
-    if (tm0.tm_isdst) {
-      // The civil time did not exist (pre >= trans > post).
-      const time_point<seconds> pre = FromUnixSeconds(t0);
-      const time_point<seconds> post = FromUnixSeconds(t1);
-      return {time_zone::civil_lookup::SKIPPED, pre, trans, post};
-    }
-
-    // The civil time was ambiguous (pre < trans <= post).
-    const time_point<seconds> pre = FromUnixSeconds(t1);
-    const time_point<seconds> post = FromUnixSeconds(t0);
-    return {time_zone::civil_lookup::REPEATED, pre, trans, post};
-  }
-
-  // make_time() failed somehow so we saturate the result.
-  const time_point<seconds> tp = (cs < civil_second())
-                                     ? time_point<seconds>::min()
-                                     : time_point<seconds>::max();
-  return {time_zone::civil_lookup::UNIQUE, tp, tp, tp};
-}
-
-bool TimeZoneLibC::NextTransition(const time_point<seconds>&,
-                                  time_zone::civil_transition*) const {
-  return false;
-}
-
-bool TimeZoneLibC::PrevTransition(const time_point<seconds>&,
-                                  time_zone::civil_transition*) const {
-  return false;
-}
-
-std::string TimeZoneLibC::Version() const {
-  return std::string();  // unknown
-}
-
-std::string TimeZoneLibC::Description() const {
-  return local_ ? "localtime" : "UTC";
-}
-
-TimeZoneLibC::TimeZoneLibC(const std::string& name)
-    : local_(name == "localtime") {}
-
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
-}  // namespace absl

package/deps/abseil-cpp/absl/time/internal/cctz/src/time_zone_libc.h

@@ -1,60 +0,0 @@
-// Copyright 2016 Google Inc. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//   https://www.apache.org/licenses/LICENSE-2.0
-//
-//   Unless required by applicable law or agreed to in writing, software
-//   distributed under the License is distributed on an "AS IS" BASIS,
-//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-//   See the License for the specific language governing permissions and
-//   limitations under the License.
-
-#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
-#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
-
-#include <memory>
-#include <string>
-
-#include "absl/base/config.h"
-#include "absl/time/internal/cctz/src/time_zone_if.h"
-
-namespace absl {
-ABSL_NAMESPACE_BEGIN
-namespace time_internal {
-namespace cctz {
-
-// A time zone backed by gmtime_r(3), localtime_r(3), and mktime(3),
-// and which therefore only supports UTC and the local time zone.
-class TimeZoneLibC : public TimeZoneIf {
- public:
-  // Factory.
-  static std::unique_ptr<TimeZoneLibC> Make(const std::string& name);
-
-  // TimeZoneIf implementations.
-  time_zone::absolute_lookup BreakTime(
-      const time_point<seconds>& tp) const override;
-  time_zone::civil_lookup MakeTime(const civil_second& cs) const override;
-  bool NextTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const override;
-  bool PrevTransition(const time_point<seconds>& tp,
-                      time_zone::civil_transition* trans) const override;
-  std::string Version() const override;
-  std::string Description() const override;
-
- private:
-  explicit TimeZoneLibC(const std::string& name);
-  TimeZoneLibC(const TimeZoneLibC&) = delete;
-  TimeZoneLibC& operator=(const TimeZoneLibC&) = delete;
-
-  const bool local_;  // localtime or UTC
-};
-
-}  // namespace cctz
-}  // namespace time_internal
-ABSL_NAMESPACE_END
-}  // namespace absl
-
-#endif  // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_