catboost 1.25.1 → 1.26.0

package/inc/util/charset/wide_specific.h

@@ -1,22 +0,0 @@
-#pragma once
-
-#include <util/system/types.h>
-#include <util/system/yassert.h>
-
-inline constexpr bool IsW16SurrogateLead(wchar16 c) noexcept {
-    return 0xD800 <= c && c <= 0xDBFF;
-}
-
-inline constexpr bool IsW16SurrogateTail(wchar16 c) noexcept {
-    return 0xDC00 <= c && c <= 0xDFFF;
-}
-
-inline size_t W16SymbolSize(const wchar16* begin, const wchar16* end) {
-    Y_ASSERT(begin < end);
-
-    if ((begin + 1 != end) && IsW16SurrogateLead(*begin) && IsW16SurrogateTail(*(begin + 1))) {
-        return 2;
-    }
-
-    return 1;
-}

package/inc/util/datetime/base.h

@@ -1,669 +0,0 @@
-#pragma once
-
-#include "systime.h"
-
-#include <util/str_stl.h>
-#include <util/system/platform.h>
-#include <util/system/datetime.h>
-#include <util/generic/string.h>
-#include <util/generic/strbuf.h>
-#include <util/generic/ylimits.h>
-#include <util/generic/utility.h>
-#include <util/generic/typetraits.h>
-#include <util/generic/yexception.h>
-
-#include <ctime>
-#include <cstdio>
-
-#include <time.h>
-
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable : 4244) // conversion from 'time_t' to 'long', possible loss of data
-#endif                          // _MSC_VER
-
-// Microseconds since epoch
-class TInstant;
-
-// Duration is microseconds. Could be used to store timeouts, for example.
-class TDuration;
-
-/// Current time
-static inline TInstant Now() noexcept;
-
-/// Use Now() method to obtain current time instead of *Seconds() unless you understand what are you doing.
-
-class TDateTimeParseException: public yexception {
-};
-
-const int DATE_BUF_LEN = 4 + 2 + 2 + 1; // [YYYYMMDD*]
-
-constexpr long seconds(const struct tm& theTm) {
-    return 60 * (60 * theTm.tm_hour + theTm.tm_min) + theTm.tm_sec;
-}
-
-void sprint_gm_date(char* buf, time_t when, long* sec = nullptr);
-bool sscan_date(const char* date, struct tm& theTm);
-
-const int DATE_8601_LEN = 21; // strlen("YYYY-MM-DDThh:mm:ssZ") = 20 + '\0'
-
-size_t FormatDate8601(char* buf, size_t len, time_t when);
-
-inline void sprint_date8601(char* buf, time_t when) {
-    buf[FormatDate8601(buf, 64, when)] = 0;
-}
-
-bool ParseISO8601DateTimeDeprecated(const char* date, time_t& utcTime);
-bool ParseISO8601DateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime);
-bool ParseRFC822DateTimeDeprecated(const char* date, time_t& utcTime);
-bool ParseRFC822DateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime);
-bool ParseHTTPDateTimeDeprecated(const char* date, time_t& utcTime);
-bool ParseHTTPDateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime);
-bool ParseX509ValidityDateTimeDeprecated(const char* date, time_t& utcTime);
-bool ParseX509ValidityDateTimeDeprecated(const char* date, size_t dateLen, time_t& utcTime);
-
-bool ParseISO8601DateTime(const char* date, time_t& utcTime);
-bool ParseISO8601DateTime(const char* date, size_t dateLen, time_t& utcTime);
-bool ParseRFC822DateTime(const char* date, time_t& utcTime);
-bool ParseRFC822DateTime(const char* date, size_t dateLen, time_t& utcTime);
-bool ParseHTTPDateTime(const char* date, time_t& utcTime);
-bool ParseHTTPDateTime(const char* date, size_t dateLen, time_t& utcTime);
-bool ParseX509ValidityDateTime(const char* date, time_t& utcTime);
-bool ParseX509ValidityDateTime(const char* date, size_t dateLen, time_t& utcTime);
-
-constexpr long TVdiff(timeval r1, timeval r2) {
-    return (1000000 * (r2.tv_sec - r1.tv_sec) + (r2.tv_usec - r1.tv_usec));
-}
-
-TString Strftime(const char* format, const struct tm* tm);
-
-// Use functions below instead of sprint_date (check IGNIETFERRO-892 for details)
-void DateToString(char* buf, const struct tm& theTm);
-void DateToString(char* buf, time_t when, long* sec = nullptr);
-TString DateToString(const struct tm& theTm);
-TString DateToString(time_t when, long* sec = nullptr);
-// Year in format "YYYY", throws an exception if year not in range [0, 9999]
-TString YearToString(const struct tm& theTm);
-TString YearToString(time_t when);
-
-template <class S>
-class TTimeBase {
-public:
-    using TValue = ui64;
-
-protected:
-    constexpr TTimeBase(const TValue& value) noexcept
-        : Value_(value)
-    {
-    }
-
-public:
-    constexpr TTimeBase() noexcept
-        : Value_(0)
-    {
-    }
-
-    constexpr TTimeBase(const struct timeval& tv) noexcept
-        : Value_(tv.tv_sec * (ui64)1000000 + tv.tv_usec)
-    {
-    }
-
-    constexpr TValue GetValue() const noexcept {
-        return Value_;
-    }
-
-    constexpr double SecondsFloat() const noexcept {
-        return Value_ * (1 / 1000000.0);
-    }
-
-    constexpr double MillisecondsFloat() const noexcept {
-        return Value_ * (1 / 1000.0);
-    }
-
-    constexpr TValue MicroSeconds() const noexcept {
-        return Value_;
-    }
-
-    constexpr TValue MilliSeconds() const noexcept {
-        return MicroSeconds() / 1000;
-    }
-
-    constexpr TValue Seconds() const noexcept {
-        return MilliSeconds() / 1000;
-    }
-
-    constexpr TValue Minutes() const noexcept {
-        return Seconds() / 60;
-    }
-
-    constexpr TValue Hours() const noexcept {
-        return Minutes() / 60;
-    }
-
-    constexpr TValue Days() const noexcept {
-        return Hours() / 24;
-    }
-
-    constexpr TValue NanoSeconds() const noexcept {
-        return MicroSeconds() >= (Max<TValue>() / (TValue)1000) ? Max<TValue>() : MicroSeconds() * (TValue)1000;
-    }
-
-    constexpr ui32 MicroSecondsOfSecond() const noexcept {
-        return MicroSeconds() % (TValue)1000000;
-    }
-
-    constexpr ui32 MilliSecondsOfSecond() const noexcept {
-        return MicroSecondsOfSecond() / (TValue)1000;
-    }
-
-    constexpr ui32 NanoSecondsOfSecond() const noexcept {
-        return MicroSecondsOfSecond() * (TValue)1000;
-    }
-
-    constexpr explicit operator bool() const noexcept {
-        return Value_;
-    }
-
-protected:
-    TValue Value_; // microseconds count
-};
-
-namespace NDateTimeHelpers {
-    template <typename T>
-    struct TPrecisionHelper {
-        using THighPrecision = ui64;
-    };
-
-    template <>
-    struct TPrecisionHelper<float> {
-        using THighPrecision = double;
-    };
-
-    template <>
-    struct TPrecisionHelper<double> {
-        using THighPrecision = double;
-    };
-}
-
-class TDuration: public TTimeBase<TDuration> {
-    using TBase = TTimeBase<TDuration>;
-
-private:
-    /**
-     * private construct from microseconds
-     */
-    constexpr explicit TDuration(TValue value) noexcept
-        : TBase(value)
-    {
-    }
-
-public:
-    constexpr TDuration() noexcept {
-    }
-
-    constexpr TDuration(const struct timeval& tv) noexcept
-        : TBase(tv)
-    {
-    }
-
-    static constexpr TDuration FromValue(TValue value) noexcept {
-        return TDuration(value);
-    }
-
-    static constexpr TDuration MicroSeconds(ui64 us) noexcept {
-        return TDuration(us);
-    }
-
-    /* noexcept(false) as conversion from T might throw, for example FromString("abc") */
-    template <typename T>
-    static constexpr TDuration MilliSeconds(T ms) noexcept(false) {
-        return MicroSeconds((ui64)(typename NDateTimeHelpers::TPrecisionHelper<T>::THighPrecision(ms) * 1000));
-    }
-
-    using TBase::Days;
-    using TBase::Hours;
-    using TBase::MicroSeconds;
-    using TBase::MilliSeconds;
-    using TBase::Minutes;
-    using TBase::Seconds;
-
-    /// DeadLineFromTimeOut
-    inline TInstant ToDeadLine() const;
-    constexpr TInstant ToDeadLine(TInstant now) const;
-
-    static constexpr TDuration Max() noexcept {
-        return TDuration(::Max<TValue>());
-    }
-
-    static constexpr TDuration Zero() noexcept {
-        return TDuration();
-    }
-
-    /* noexcept(false) as conversion from T might throw, for example FromString("abc") */
-    template <typename T>
-    static constexpr TDuration Seconds(T s) noexcept(false) {
-        return MilliSeconds(typename NDateTimeHelpers::TPrecisionHelper<T>::THighPrecision(s) * 1000);
-    }
-
-    static constexpr TDuration Minutes(ui64 m) noexcept {
-        return Seconds(m * 60);
-    }
-
-    static constexpr TDuration Hours(ui64 h) noexcept {
-        return Minutes(h * 60);
-    }
-
-    static constexpr TDuration Days(ui64 d) noexcept {
-        return Hours(d * 24);
-    }
-
-    /// parses strings like 10s, 15ms, 15.05s, 20us, or just 25 (s). See parser_ut.cpp for details
-    static TDuration Parse(const TStringBuf input);
-
-    static bool TryParse(const TStringBuf input, TDuration& result);
-
-    // note global Out method is defined for TDuration, so it could be written to IOutputStream as text
-
-    template <class T>
-    inline TDuration& operator+=(const T& t) noexcept {
-        return (*this = (*this + t));
-    }
-
-    template <class T>
-    inline TDuration& operator-=(const T& t) noexcept {
-        return (*this = (*this - t));
-    }
-
-    template <class T>
-    inline TDuration& operator*=(const T& t) noexcept {
-        return (*this = (*this * t));
-    }
-
-    template <class T>
-    inline TDuration& operator/=(const T& t) noexcept {
-        return (*this = (*this / t));
-    }
-
-    TString ToString() const;
-};
-
-Y_DECLARE_PODTYPE(TDuration);
-
-template <>
-struct THash<TDuration> {
-    size_t operator()(const TDuration& key) const {
-        return THash<TDuration::TValue>()(key.GetValue());
-    }
-};
-
-/// TInstant and TDuration are guaranteed to have same precision
-class TInstant: public TTimeBase<TInstant> {
-    using TBase = TTimeBase<TInstant>;
-
-private:
-    /**
-     * private construct from microseconds since epoch
-     */
-    constexpr explicit TInstant(TValue value) noexcept
-        : TBase(value)
-    {
-    }
-
-public:
-    constexpr TInstant() noexcept {
-    }
-
-    constexpr TInstant(const struct timeval& tv) noexcept
-        : TBase(tv)
-    {
-    }
-
-    static constexpr TInstant FromValue(TValue value) noexcept {
-        return TInstant(value);
-    }
-
-    static inline TInstant Now() {
-        return TInstant::MicroSeconds(::MicroSeconds());
-    }
-
-    using TBase::Days;
-    using TBase::Hours;
-    using TBase::MicroSeconds;
-    using TBase::MilliSeconds;
-    using TBase::Minutes;
-    using TBase::Seconds;
-
-    static constexpr TInstant Max() noexcept {
-        return TInstant(::Max<TValue>());
-    }
-
-    static constexpr TInstant Zero() noexcept {
-        return TInstant();
-    }
-
-    /// us since epoch
-    static constexpr TInstant MicroSeconds(ui64 us) noexcept {
-        return TInstant(us);
-    }
-
-    /// ms since epoch
-    static constexpr TInstant MilliSeconds(ui64 ms) noexcept {
-        return MicroSeconds(ms * 1000);
-    }
-
-    /// seconds since epoch
-    static constexpr TInstant Seconds(ui64 s) noexcept {
-        return MilliSeconds(s * 1000);
-    }
-
-    /// minutes since epoch
-    static constexpr TInstant Minutes(ui64 m) noexcept {
-        return Seconds(m * 60);
-    }
-
-    /// hours since epoch
-    static constexpr TInstant Hours(ui64 h) noexcept {
-        return Minutes(h * 60);
-    }
-
-    /// days since epoch
-    static constexpr TInstant Days(ui64 d) noexcept {
-        return Hours(d * 24);
-    }
-
-    constexpr time_t TimeT() const noexcept {
-        return (time_t)Seconds();
-    }
-
-    inline struct timeval TimeVal() const noexcept {
-        struct timeval tv;
-        ::Zero(tv);
-        tv.tv_sec = TimeT();
-        tv.tv_usec = MicroSecondsOfSecond();
-        return tv;
-    }
-
-    inline struct tm* LocalTime(struct tm* tm) const noexcept {
-        time_t clock = Seconds();
-        return localtime_r(&clock, tm);
-    }
-
-    inline struct tm* GmTime(struct tm* tm) const noexcept {
-        time_t clock = Seconds();
-        return GmTimeR(&clock, tm);
-    }
-
-    /**
-     * Formats the instant using the UTC time zone, with microsecond precision.
-     *
-     * @returns An ISO 8601 formatted string, e.g. '2015-11-21T23:30:27.991669Z'.
-     * @note Global Out method is defined to TInstant, so it can be written as text to IOutputStream.
-     */
-    TString ToString() const;
-
-    /**
-     * Formats the instant using the UTC time zone.
-     *
-     * @returns An RFC822 formatted string, e.g. 'Sun, 06 Nov 1994 08:49:37 GMT'.
-     */
-    TString ToRfc822String() const;
-
-    /**
-     * Formats the instant using the UTC time zone, with second precision.
-     *
-     * @returns An ISO 8601 formatted string, e.g. '2015-11-21T23:30:27Z'.
-     */
-    TString ToStringUpToSeconds() const;
-
-    /**
-     * Formats the instant using the system time zone, with microsecond precision.
-     *
-     * @returns An ISO 8601 / RFC 3339 formatted string,
-     * e.g. '2015-11-22T04:30:27.991669+05:00'.
-     */
-    TString ToIsoStringLocal() const;
-
-    /**
-     * Formats the instant using the system time zone, with microsecond precision.
-     *
-     * @returns A semi-ISO 8601 formatted string with timezone without colon,
-     * e.g. '2015-11-22T04:30:27.991669+0500'.
-     */
-    TString ToStringLocal() const;
-
-    /**
-     * Formats the instant using the system time zone.
-     *
-     * @returns An RFC822 formatted string, e.g. 'Sun, 06 Nov 1994 08:49:37 MSK'.
-     */
-    TString ToRfc822StringLocal() const;
-
-    /**
-     * Formats the instant using the system time zone, with second precision.
-     *
-     * @returns An ISO 8601 / RFC 3339 formatted string,
-     * e.g. '2015-11-22T04:30:27+05:00'.
-     */
-    TString ToIsoStringLocalUpToSeconds() const;
-
-    /**
-     * Formats the instant using the system time zone, with second precision.
-     *
-     * @returns A semi-ISO 8601 formatted string with timezone without colon,
-     * e.g. '2015-11-22T04:30:27+0500'.
-     */
-    TString ToStringLocalUpToSeconds() const;
-
-    TString FormatLocalTime(const char* format) const noexcept;
-    TString FormatGmTime(const char* format) const noexcept;
-
-    /// See #TryParseIso8601.
-    static TInstant ParseIso8601(TStringBuf);
-    /// See #TryParseRfc822.
-    static TInstant ParseRfc822( TStringBuf);
-    /// See #TryParseHttp.
-    static TInstant ParseHttp(TStringBuf);
-    /// See #TryParseX509.
-    static TInstant ParseX509Validity(TStringBuf);
-
-    /// ISO 8601 Representation of Dates and Times
-    ///
-    /// @link https://www.iso.org/standard/40874.html Description of format.
-    static bool TryParseIso8601(TStringBuf input, TInstant& instant);
-
-    /// RFC 822 Date and Time specification
-    ///
-    /// @link https://tools.ietf.org/html/rfc822#section-5 Description of format.
-    static bool TryParseRfc822(TStringBuf input, TInstant& instant);
-
-    /// RFC 2616 3.3.1 Full Date
-    ///
-    /// @link https://tools.ietf.org/html/rfc2616#section-3.3.1 Description of format.
-    static bool TryParseHttp(TStringBuf input, TInstant& instant);
-
-    /// X.509 certificate validity time (see rfc5280 4.1.2.5.*)
-    ///
-    /// @link https://tools.ietf.org/html/rfc5280#section-4.1.2.5 Description of format.
-    static bool TryParseX509(TStringBuf input, TInstant& instant);
-
-    static TInstant ParseIso8601Deprecated(TStringBuf);
-    static TInstant ParseRfc822Deprecated(TStringBuf);
-    static TInstant ParseHttpDeprecated(TStringBuf);
-    static TInstant ParseX509ValidityDeprecated(TStringBuf);
-
-    static bool TryParseIso8601Deprecated(TStringBuf input, TInstant& instant);
-    static bool TryParseRfc822Deprecated(TStringBuf input, TInstant& instant);
-    static bool TryParseHttpDeprecated(TStringBuf input, TInstant& instant);
-    static bool TryParseX509Deprecated(TStringBuf input, TInstant& instant);
-
-    template <class T>
-    inline TInstant& operator+=(const T& t) noexcept {
-        return (*this = (*this + t));
-    }
-
-    template <class T>
-    inline TInstant& operator-=(const T& t) noexcept {
-        return (*this = (*this - t));
-    }
-};
-
-Y_DECLARE_PODTYPE(TInstant);
-
-template <>
-struct THash<TInstant> {
-    size_t operator()(const TInstant& key) const {
-        return THash<TInstant::TValue>()(key.GetValue());
-    }
-};
-
-namespace NPrivate {
-    template <bool PrintUpToSeconds, bool iso>
-    struct TPrintableLocalTime {
-        TInstant MomentToPrint;
-
-        constexpr explicit TPrintableLocalTime(TInstant momentToPrint)
-            : MomentToPrint(momentToPrint)
-        {
-        }
-    };
-}
-
-/** @name Helpers for printing local times to `IOutputStream`s.
- *        The FormatLocal* functions create an opaque object that, when written to
- *        a `IOutputStream`, outputs this instant as an ISO 8601 formatted string
- *        using the system time zone.
- *
- *  @note The only reason behind this set of functions is to avoid excessive
- *        allocations when you directly print the local time to a stream.
- *
- *        If you need something beyond just printing the value or your code
- *        is not performance-critical, feel free to use the corresponding
- *        TInstant::ToString*() functions.
- */
-///@{
-/// @see TInstant::ToIsoStringLocal()
-::NPrivate::TPrintableLocalTime<false, true> FormatIsoLocal(TInstant instant);
-/// @see TInstant::ToStringLocal()
-::NPrivate::TPrintableLocalTime<false, false> FormatLocal(TInstant instant);
-/// @see TInstant::ToIsoStringLocalUpToSeconds()
-::NPrivate::TPrintableLocalTime<true, true> FormatIsoLocalUpToSeconds(TInstant instant);
-/// @see TInstant::ToStringLocalUpToSeconds()
-::NPrivate::TPrintableLocalTime<true, false> FormatLocalUpToSeconds(TInstant instant);
-///@}
-
-template <class S>
-static constexpr bool operator<(const TTimeBase<S>& l, const TTimeBase<S>& r) noexcept {
-    return l.GetValue() < r.GetValue();
-}
-
-template <class S>
-static constexpr bool operator<=(const TTimeBase<S>& l, const TTimeBase<S>& r) noexcept {
-    return l.GetValue() <= r.GetValue();
-}
-
-template <class S>
-static constexpr bool operator==(const TTimeBase<S>& l, const TTimeBase<S>& r) noexcept {
-    return l.GetValue() == r.GetValue();
-}
-
-template <class S>
-static constexpr bool operator!=(const TTimeBase<S>& l, const TTimeBase<S>& r) noexcept {
-    return l.GetValue() != r.GetValue();
-}
-
-template <class S>
-static constexpr bool operator>(const TTimeBase<S>& l, const TTimeBase<S>& r) noexcept {
-    return l.GetValue() > r.GetValue();
-}
-
-template <class S>
-static constexpr bool operator>=(const TTimeBase<S>& l, const TTimeBase<S>& r) noexcept {
-    return l.GetValue() >= r.GetValue();
-}
-
-namespace NDateTimeHelpers {
-    template <typename T>
-    static constexpr T SumWithSaturation(T a, T b) {
-        static_assert(!std::numeric_limits<T>::is_signed, "expect !std::numeric_limits<T>::is_signed");
-
-        return Max<T>() - a < b ? Max<T>() : a + b;
-    }
-
-    template <typename T>
-    static constexpr T DiffWithSaturation(T a, T b) {
-        static_assert(!std::numeric_limits<T>::is_signed, "expect !std::numeric_limits<T>::is_signed");
-
-        return a < b ? 0 : a - b;
-    }
-}
-
-constexpr TDuration operator-(const TInstant& l, const TInstant& r) noexcept {
-    return TDuration::FromValue(::NDateTimeHelpers::DiffWithSaturation(l.GetValue(), r.GetValue()));
-}
-
-constexpr TInstant operator+(const TInstant& i, const TDuration& d) noexcept {
-    return TInstant::FromValue(::NDateTimeHelpers::SumWithSaturation(i.GetValue(), d.GetValue()));
-}
-
-constexpr TInstant operator-(const TInstant& i, const TDuration& d) noexcept {
-    return TInstant::FromValue(::NDateTimeHelpers::DiffWithSaturation(i.GetValue(), d.GetValue()));
-}
-
-constexpr TDuration operator-(const TDuration& l, const TDuration& r) noexcept {
-    return TDuration::FromValue(::NDateTimeHelpers::DiffWithSaturation(l.GetValue(), r.GetValue()));
-}
-
-constexpr TDuration operator+(const TDuration& l, const TDuration& r) noexcept {
-    return TDuration::FromValue(::NDateTimeHelpers::SumWithSaturation(l.GetValue(), r.GetValue()));
-}
-
-template <class T>
-inline TDuration operator*(TDuration d, T t) noexcept {
-    Y_ASSERT(t >= T());
-    Y_ASSERT(t == T() || Max<TDuration::TValue>() / t >= d.GetValue());
-    return TDuration::FromValue(d.GetValue() * t);
-}
-
-template <>
-inline TDuration operator*(TDuration d, double t) noexcept {
-    Y_ASSERT(t >= 0 && MaxFloor<TDuration::TValue>() >= d.GetValue() * t);
-    return TDuration::FromValue(d.GetValue() * t);
-}
-
-template <>
-inline TDuration operator*(TDuration d, float t) noexcept {
-    return d * static_cast<double>(t);
-}
-
-template <class T>
-inline TDuration operator*(T t, TDuration d) noexcept {
-    return d * t;
-}
-
-template <class T, std::enable_if_t<!std::is_same<TDuration, T>::value, int> = 0>
-constexpr TDuration operator/(const TDuration& d, const T& t) noexcept {
-    return TDuration::FromValue(d.GetValue() / t);
-}
-
-constexpr double operator/(const TDuration& x, const TDuration& y) noexcept {
-    return static_cast<double>(x.GetValue()) / static_cast<double>(y.GetValue());
-}
-
-inline TInstant TDuration::ToDeadLine() const {
-    return ToDeadLine(TInstant::Now());
-}
-
-constexpr TInstant TDuration::ToDeadLine(TInstant now) const {
-    return now + *this;
-}
-
-void Sleep(TDuration duration);
-void SleepUntil(TInstant instant);
-
-static inline TInstant Now() noexcept {
-    return TInstant::Now();
-}
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif // _MSC_VER

package/inc/util/datetime/constants.h

@@ -1,7 +0,0 @@
-#pragma once
-
-#include <time.h>
-
-const time_t SECONDS_IN_DAY = 86400;
-const time_t SECONDS_IN_HOUR = 3600;
-const time_t SECONDS_IN_HALFHOUR = 1800;