catboost 1.25.1 → 1.26.0

package/inc/util/string/ascii.h

@@ -1,236 +0,0 @@
-#pragma once
-
-#include <util/system/defaults.h>
-#include <util/system/compat.h>
-#include <util/generic/string.h>
-
-// ctype.h-like functions, locale-independent:
-//      IsAscii{Upper,Lower,Digit,Alpha,Alnum,Space} and
-//      AsciiTo{Upper,Lower}
-//
-// standard functions from <ctype.h> are locale dependent,
-// and cause undefined behavior when called on chars outside [0..127] range
-
-namespace NPrivate {
-    enum ECharClass {
-        CC_SPACE = 1,
-        CC_UPPER = 2,
-        CC_LOWER = 4,
-        CC_DIGIT = 8,
-        CC_ALPHA = 16,
-        CC_ALNUM = 32,
-        CC_ISHEX = 64,
-        CC_PUNCT = 128,
-    };
-
-    extern const unsigned char ASCII_CLASS[256];
-    extern const unsigned char ASCII_LOWER[256];
-
-    template <class T>
-    struct TDereference {
-        using type = T;
-    };
-
-#ifndef TSTRING_IS_STD_STRING
-    template <class String>
-    struct TDereference<TBasicCharRef<String>> {
-        using type = typename String::value_type;
-    };
-#endif
-
-    template <class T>
-    using TDereferenced = typename TDereference<T>::type;
-
-    template <class T>
-    bool RangeOk(T c) noexcept {
-        static_assert(std::is_integral<T>::value, "Integral type character expected");
-
-        if (sizeof(T) == 1) {
-            return true;
-        }
-
-        return c >= static_cast<T>(0) && c <= static_cast<T>(127);
-    }
-
-#ifndef TSTRING_IS_STD_STRING
-    template <class String>
-    bool RangeOk(const TBasicCharRef<String>& c) {
-        return RangeOk(static_cast<typename String::value_type>(c));
-    }
-#endif
-}
-
-constexpr bool IsAscii(const int c) noexcept {
-    return !(c & ~0x7f);
-}
-
-inline bool IsAsciiSpace(unsigned char c) {
-    return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_SPACE;
-}
-
-inline bool IsAsciiUpper(unsigned char c) {
-    return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_UPPER;
-}
-
-inline bool IsAsciiLower(unsigned char c) {
-    return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_LOWER;
-}
-
-inline bool IsAsciiDigit(unsigned char c) {
-    return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_DIGIT;
-}
-
-inline bool IsAsciiAlpha(unsigned char c) {
-    return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_ALPHA;
-}
-
-inline bool IsAsciiAlnum(unsigned char c) {
-    return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_ALNUM;
-}
-
-inline bool IsAsciiHex(unsigned char c) {
-    return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_ISHEX;
-}
-
-inline bool IsAsciiPunct(unsigned char c) {
-    return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_PUNCT;
-}
-
-// some overloads
-
-template <class T>
-inline bool IsAsciiSpace(T c) {
-    return ::NPrivate::RangeOk(c) && IsAsciiSpace(static_cast<unsigned char>(c));
-}
-
-template <class T>
-inline bool IsAsciiUpper(T c) {
-    return ::NPrivate::RangeOk(c) && IsAsciiUpper(static_cast<unsigned char>(c));
-}
-
-template <class T>
-inline bool IsAsciiLower(T c) {
-    return ::NPrivate::RangeOk(c) && IsAsciiLower(static_cast<unsigned char>(c));
-}
-
-template <class T>
-inline bool IsAsciiDigit(T c) {
-    return ::NPrivate::RangeOk(c) && IsAsciiDigit(static_cast<unsigned char>(c));
-}
-
-template <class T>
-inline bool IsAsciiAlpha(T c) {
-    return ::NPrivate::RangeOk(c) && IsAsciiAlpha(static_cast<unsigned char>(c));
-}
-
-template <class T>
-inline bool IsAsciiAlnum(T c) {
-    return ::NPrivate::RangeOk(c) && IsAsciiAlnum(static_cast<unsigned char>(c));
-}
-
-template <class T>
-inline bool IsAsciiHex(T c) {
-    return ::NPrivate::RangeOk(c) && IsAsciiHex(static_cast<unsigned char>(c));
-}
-
-template <class T>
-inline bool IsAsciiPunct(T c) {
-    return ::NPrivate::RangeOk(c) && IsAsciiPunct(static_cast<unsigned char>(c));
-}
-
-// some extra helpers
-inline ui8 AsciiToLower(ui8 c) noexcept {
-    return ::NPrivate::ASCII_LOWER[c];
-}
-
-inline char AsciiToLower(char c) noexcept {
-    return (char)AsciiToLower((ui8)c);
-}
-
-template <class T>
-inline ::NPrivate::TDereferenced<T> AsciiToLower(T c) noexcept {
-    return (c >= 0 && c <= 127) ? (::NPrivate::TDereferenced<T>)AsciiToLower((ui8)c) : c;
-}
-
-template <class T>
-inline ::NPrivate::TDereferenced<T> AsciiToUpper(T c) noexcept {
-    return IsAsciiLower(c) ? (c + ('A' - 'a')) : c;
-}
-
-/**
- * ASCII case-insensitive string comparison (for proper UTF8 strings
- * case-insensitive comparison consider using @c library/cpp/charset).
- *
- * @return                              true iff @c s1 ans @c s2 are case-insensitively equal.
- */
-static inline bool AsciiEqualsIgnoreCase(const char* s1, const char* s2) noexcept {
-    return stricmp(s1, s2) == 0;
-}
-
-/**
- * ASCII case-insensitive string comparison (for proper UTF8 strings
- * case-insensitive comparison consider using @c library/cpp/charset).
- *
- * @return                              true iff @c s1 ans @c s2 are case-insensitively equal.
- */
-static inline bool AsciiEqualsIgnoreCase(const TStringBuf s1, const TStringBuf s2) noexcept {
-    return (s1.size() == s2.size()) && strnicmp(s1.data(), s2.data(), s1.size()) == 0;
-}
-
-/**
- * ASCII case-insensitive string comparison (for proper UTF8 strings
- * case-insensitive comparison consider using @c library/cpp/charset).
- *
- * @return                              0 if strings are equal, negative if @c s1 < @c s2
- *                                      and positive otherwise.
- *                                      (same value as @c stricmp does).
- */
-static inline int AsciiCompareIgnoreCase(const char* s1, const char* s2) noexcept {
-    return stricmp(s1, s2);
-}
-
-/**
- * ASCII case-insensitive string comparison (for proper UTF8 strings
- * case-insensitive comparison consider using @c library/cpp/charset).
- *
- * @return
- * - zero if strings are equal
- * - negative if @c s1 < @c s2
- * - positive otherwise,
- * similar to stricmp.
- *
- * BUGS: Currently will NOT work properly with strings that contain
- * 0-terminator character inside.
- */
-Y_PURE_FUNCTION
-int AsciiCompareIgnoreCase(const TStringBuf s1, const TStringBuf s2) noexcept;
-
-/**
-  * ASCII case-sensitive string comparison (for proper UTF8 strings
-  * case-sensitive comparison consider using @c library/cpp/charset).
-  *
-  * @return                              true iff @c s2 are case-sensitively prefix of @c s1.
-  */
-static inline bool AsciiHasPrefix(const TStringBuf s1, const TStringBuf s2) noexcept {
-    return (s1.size() >= s2.size()) && memcmp(s1.data(), s2.data(), s2.size()) == 0;
-}
-
-/**
-  * ASCII case-insensitive string comparison (for proper UTF8 strings
-  * case-insensitive comparison consider using @c library/cpp/charset).
-  *
-  * @return                              true iff @c s2 are case-insensitively prefix of @c s1.
-  */
-static inline bool AsciiHasPrefixIgnoreCase(const TStringBuf s1, const TStringBuf s2) noexcept {
-    return (s1.size() >= s2.size()) && strnicmp(s1.data(), s2.data(), s2.size()) == 0;
-}
-
-/**
-  * ASCII case-insensitive string comparison (for proper UTF8 strings
-  * case-insensitive comparison consider using @c library/cpp/charset).
-  *
-  * @return                              true iff @c s2 are case-insensitively suffix of @c s1.
-  */
-static inline bool AsciiHasSuffixIgnoreCase(const TStringBuf s1, const TStringBuf s2) noexcept {
-    return (s1.size() >= s2.size()) && strnicmp((s1.data() + (s1.size() - s2.size())), s2.data(), s2.size()) == 0;
-}

package/inc/util/string/builder.h

@@ -1,39 +0,0 @@
-#pragma once
-
-#include <util/stream/str.h>
-#include <utility>
-#include <util/generic/string.h>
-
-namespace NPrivateStringBuilder {
-    class TStringBuilder: public TString {
-    public:
-        inline TStringBuilder()
-            : Out(*this)
-        {
-        }
-
-        TStringBuilder(TStringBuilder&& rhs)
-            : TString(std::move(rhs))
-            , Out(*this)
-        {
-        }
-
-        TStringOutput Out;
-    };
-
-    template <class T>
-    static inline TStringBuilder& operator<<(TStringBuilder& builder, const T& t) {
-        builder.Out << t;
-
-        return builder;
-    }
-
-    template <class T>
-    static inline TStringBuilder&& operator<<(TStringBuilder&& builder, const T& t) {
-        builder.Out << t;
-
-        return std::move(builder);
-    }
-}
-
-using TStringBuilder = NPrivateStringBuilder::TStringBuilder;

package/inc/util/string/cast.h

@@ -1,347 +0,0 @@
-#pragma once
-
-#include <util/system/defaults.h>
-#include <util/stream/str.h>
-#include <util/generic/string.h>
-#include <util/generic/strbuf.h>
-#include <util/generic/typetraits.h>
-#include <util/generic/yexception.h>
-
-/*
- * specialized for all arithmetic types
- */
-
-template <class T>
-size_t ToStringImpl(T t, char* buf, size_t len);
-
-/**
- * Converts @c t to string writing not more than @c len bytes to output buffer @c buf.
- * No NULL terminator appended! Throws exception on buffer overflow.
- * @return number of bytes written
- */
-template <class T>
-inline size_t ToString(const T& t, char* buf, size_t len) {
-    using TParam = typename TTypeTraits<T>::TFuncParam;
-
-    return ToStringImpl<TParam>(t, buf, len);
-}
-
-/**
- * Floating point to string conversion mode, values are enforced by `dtoa_impl.cpp`.
- */
-enum EFloatToStringMode {
-    /** 0.1f -> "0.1", 0.12345678f -> "0.12345678", ignores ndigits. */
-    PREC_AUTO = 0,
-
-    /** "%g" mode, writes up to the given number of significant digits:
-     *  0.1f -> "0.1", 0.12345678f -> "0.123457" for ndigits=6, 1.2e-06f -> "1.2e-06" */
-    PREC_NDIGITS = 2,
-
-    /** "%f" mode, writes the given number of digits after decimal point:
-     *  0.1f -> "0.100000", 1.2e-06f -> "0.000001" for ndigits=6 */
-    PREC_POINT_DIGITS = 3,
-
-    /** same as PREC_POINT_DIGITS, but stripping trailing zeroes:
-     * 0.1f for ndgigits=6 -> "0.1" */
-    PREC_POINT_DIGITS_STRIP_ZEROES = 4
-};
-
-size_t FloatToString(float t, char* buf, size_t len, EFloatToStringMode mode = PREC_AUTO, int ndigits = 0);
-size_t FloatToString(double t, char* buf, size_t len, EFloatToStringMode mode = PREC_AUTO, int ndigits = 0);
-
-template <typename T>
-inline TString FloatToString(const T& t, EFloatToStringMode mode = PREC_AUTO, int ndigits = 0) {
-    char buf[512]; // Max<double>() with mode = PREC_POINT_DIGITS has 309 digits before the decimal point
-    size_t count = FloatToString(t, buf, sizeof(buf), mode, ndigits);
-    return TString(buf, count);
-}
-
-namespace NPrivate {
-    template <class T, bool isSimple>
-    struct TToString {
-        static inline TString Cvt(const T& t) {
-            char buf[512];
-
-            return TString(buf, ToString<T>(t, buf, sizeof(buf)));
-        }
-    };
-
-    template <class T>
-    struct TToString<T, false> {
-        static inline TString Cvt(const T& t) {
-            TString s;
-            TStringOutput o(s);
-            o << t;
-            return s;
-        }
-    };
-}
-
-/*
- * some clever implementations...
- */
-template <class T>
-inline TString ToString(const T& t) {
-    using TR = std::remove_cv_t<T>;
-
-    return ::NPrivate::TToString<TR, std::is_arithmetic<TR>::value>::Cvt((const TR&)t);
-}
-
-inline const TString& ToString(const TString& s) noexcept {
-    return s;
-}
-
-inline const TString& ToString(TString& s) noexcept {
-    return s;
-}
-
-inline TString ToString(const char* s) {
-    return s;
-}
-
-inline TString ToString(char* s) {
-    return s;
-}
-
-/*
- * Wrapper for wide strings.
- */
-template <class T>
-inline TUtf16String ToWtring(const T& t) {
-    return TUtf16String::FromAscii(ToString(t));
-}
-
-inline const TUtf16String& ToWtring(const TUtf16String& w) {
-    return w;
-}
-
-inline const TUtf16String& ToWtring(TUtf16String& w) {
-    return w;
-}
-
-struct TFromStringException: public TBadCastException {
-};
-
-/*
- * specialized for:
- *  bool
- *  short
- *  unsigned short
- *  int
- *  unsigned int
- *  long
- *  unsigned long
- *  long long
- *  unsigned long long
- *  float
- *  double
- *  long double
- */
-template <typename T, typename TChar>
-T FromStringImpl(const TChar* data, size_t len);
-
-template <typename T, typename TChar>
-inline T FromString(const TChar* data, size_t len) {
-    return ::FromStringImpl<T>(data, len);
-}
-
-template <typename T, typename TChar>
-inline T FromString(const TChar* data) {
-    return ::FromString<T>(data, std::char_traits<TChar>::length(data));
-}
-
-template <class T>
-inline T FromString(const TStringBuf& s) {
-    return ::FromString<T>(s.data(), s.size());
-}
-
-template <class T>
-inline T FromString(const TString& s) {
-    return ::FromString<T>(s.data(), s.size());
-}
-
-template <>
-inline TString FromString<TString>(const TString& s) {
-    return s;
-}
-
-template <class T>
-inline T FromString(const TWtringBuf& s) {
-    return ::FromString<T, typename TWtringBuf::char_type>(s.data(), s.size());
-}
-
-template <class T>
-inline T FromString(const TUtf16String& s) {
-    return ::FromString<T, wchar16>(s.data(), s.size());
-}
-
-namespace NPrivate {
-    template <typename TChar>
-    class TFromString {
-        const TChar* const Data;
-        const size_t Len;
-
-    public:
-        inline TFromString(const TChar* data, size_t len)
-            : Data(data)
-            , Len(len)
-        {
-        }
-
-        template <typename T>
-        inline operator T() const {
-            return FromString<T, TChar>(Data, Len);
-        }
-    };
-}
-
-template <typename TChar>
-inline ::NPrivate::TFromString<TChar> FromString(const TChar* data, size_t len) {
-    return ::NPrivate::TFromString<TChar>(data, len);
-}
-
-template <typename TChar>
-inline ::NPrivate::TFromString<TChar> FromString(const TChar* data) {
-    return ::NPrivate::TFromString<TChar>(data, std::char_traits<TChar>::length(data));
-}
-
-template <typename T>
-inline ::NPrivate::TFromString<typename T::TChar> FromString(const T& s) {
-    return ::NPrivate::TFromString<typename T::TChar>(s.data(), s.size());
-}
-
-// Conversion exception free versions
-template <typename T, typename TChar>
-bool TryFromStringImpl(const TChar* data, size_t len, T& result);
-
-/**
- * @param data Source string buffer pointer
- * @param len Source string length, in characters
- * @param result Place to store conversion result value.
- * If conversion error occurs, no value stored in @c result
- * @return @c true in case of successful conversion, @c false otherwise
- **/
-template <typename T, typename TChar>
-inline bool TryFromString(const TChar* data, size_t len, T& result) {
-    return TryFromStringImpl<T>(data, len, result);
-}
-
-template <typename T, typename TChar>
-inline bool TryFromString(const TChar* data, T& result) {
-    return TryFromString<T>(data, std::char_traits<TChar>::length(data), result);
-}
-
-template <class T, class TChar>
-inline bool TryFromString(const TChar* data, const size_t len, T& result, const T& def) {
-    if (TryFromString<T>(data, len, result)) {
-        return true;
-    }
-    result = def;
-    return false;
-}
-
-template <class T>
-inline bool TryFromString(const TStringBuf& s, T& result) {
-    return TryFromString<T>(s.data(), s.size(), result);
-}
-
-template <class T>
-inline bool TryFromString(const TString& s, T& result) {
-    return TryFromString<T>(s.data(), s.size(), result);
-}
-
-template <class T>
-inline bool TryFromString(const TWtringBuf& s, T& result) {
-    return TryFromString<T>(s.data(), s.size(), result);
-}
-
-template <class T>
-inline bool TryFromString(const TUtf16String& s, T& result) {
-    return TryFromString<T>(s.data(), s.size(), result);
-}
-
-template <class T, class TStringType>
-inline bool TryFromStringWithDefault(const TStringType& s, T& result, const T& def) {
-    return TryFromString<T>(s.data(), s.size(), result, def);
-}
-
-template <class T>
-inline bool TryFromStringWithDefault(const char* s, T& result, const T& def) {
-    return TryFromStringWithDefault<T>(TStringBuf(s), result, def);
-}
-
-template <class T, class TStringType>
-inline bool TryFromStringWithDefault(const TStringType& s, T& result) {
-    return TryFromStringWithDefault<T>(s, result, T());
-}
-
-// FromString methods with default value if data is invalid
-template <class T, class TChar>
-inline T FromString(const TChar* data, const size_t len, const T& def) {
-    T result;
-    TryFromString<T>(data, len, result, def);
-    return result;
-}
-
-template <class T, class TStringType>
-inline T FromStringWithDefault(const TStringType& s, const T& def) {
-    return FromString<T>(s.data(), s.size(), def);
-}
-
-template <class T>
-inline T FromStringWithDefault(const char* s, const T& def) {
-    return FromStringWithDefault<T>(TStringBuf(s), def);
-}
-
-template <class T, class TStringType>
-inline T FromStringWithDefault(const TStringType& s) {
-    return FromStringWithDefault<T>(s, T());
-}
-
-double StrToD(const char* b, char** se);
-double StrToD(const char* b, const char* e, char** se);
-
-template <int base, class T>
-size_t IntToString(T t, char* buf, size_t len);
-
-template <int base, class T>
-inline TString IntToString(T t) {
-    static_assert(std::is_arithmetic<std::remove_cv_t<T>>::value, "expect std::is_arithmetic<std::remove_cv_t<T>>::value");
-
-    char buf[256];
-
-    return TString(buf, IntToString<base>(t, buf, sizeof(buf)));
-}
-
-template <int base, class TInt, class TChar>
-bool TryIntFromString(const TChar* data, size_t len, TInt& result);
-
-template <int base, class TInt, class TStringType>
-inline bool TryIntFromString(const TStringType& s, TInt& result) {
-    return TryIntFromString<base>(s.data(), s.size(), result);
-}
-
-template <class TInt, int base, class TChar>
-TInt IntFromString(const TChar* str, size_t len);
-
-template <class TInt, int base, class TChar>
-inline TInt IntFromString(const TChar* str) {
-    return IntFromString<TInt, base>(str, std::char_traits<TChar>::length(str));
-}
-
-template <class TInt, int base, class TStringType>
-inline TInt IntFromString(const TStringType& str) {
-    return IntFromString<TInt, base>(str.data(), str.size());
-}
-
-static inline TString ToString(const TStringBuf str) {
-    return TString(str);
-}
-
-static inline TUtf16String ToWtring(const TWtringBuf wtr) {
-    return TUtf16String(wtr);
-}
-
-static inline TUtf32String ToUtf32String(const TUtf32StringBuf wtr) {
-    return TUtf32String(wtr);
-}

package/inc/util/string/cstriter.h

@@ -1,14 +0,0 @@
-#pragma once
-
-struct TCStringEndIterator {
-};
-
-template <class It>
-static inline bool operator==(It b, TCStringEndIterator) {
-    return !*b;
-}
-
-template <class It>
-static inline bool operator!=(It b, TCStringEndIterator) {
-    return !!*b;
-}

package/inc/util/string/escape.h

@@ -1,70 +0,0 @@
-#pragma once
-
-#include <util/generic/string.h>
-#include <util/generic/strbuf.h>
-
-template <class TChar>
-TBasicString<TChar>& EscapeCImpl(const TChar* str, size_t len, TBasicString<TChar>&);
-
-template <class TChar>
-TBasicString<TChar>& UnescapeCImpl(const TChar* str, size_t len, TBasicString<TChar>&);
-
-template <class TChar>
-TChar* UnescapeC(const TChar* str, size_t len, TChar* buf);
-
-template <typename TChar>
-static inline TBasicString<TChar>& EscapeC(const TChar* str, size_t len, TBasicString<TChar>& s) {
-    return EscapeCImpl(str, len, s);
-}
-
-template <typename TChar>
-static inline TBasicString<TChar> EscapeC(const TChar* str, size_t len) {
-    TBasicString<TChar> s;
-    return EscapeC(str, len, s);
-}
-
-template <typename TChar>
-static inline TBasicString<TChar> EscapeC(const TBasicStringBuf<TChar>& str) {
-    return EscapeC(str.data(), str.size());
-}
-
-template <typename TChar>
-static inline TBasicString<TChar>& UnescapeC(const TChar* str, size_t len, TBasicString<TChar>& s) {
-    return UnescapeCImpl(str, len, s);
-}
-
-template <typename TChar>
-static inline TBasicString<TChar> UnescapeC(const TChar* str, size_t len) {
-    TBasicString<TChar> s;
-    return UnescapeCImpl(str, len, s);
-}
-
-template <typename TChar>
-static inline TBasicString<TChar> EscapeC(TChar ch) {
-    return EscapeC(&ch, 1);
-}
-
-template <typename TChar>
-static inline TBasicString<TChar> EscapeC(const TChar* str) {
-    return EscapeC(str, std::char_traits<TChar>::length(str));
-}
-
-TString& EscapeC(const TStringBuf str, TString& res);
-TUtf16String& EscapeC(const TWtringBuf str, TUtf16String& res);
-
-// these two need to be methods, because of TBasicString::Quote implementation
-TString EscapeC(const TString& str);
-TUtf16String EscapeC(const TUtf16String& str);
-
-TString& UnescapeC(const TStringBuf str, TString& res);
-TUtf16String& UnescapeC(const TWtringBuf str, TUtf16String& res);
-
-TString UnescapeC(const TStringBuf str);
-TUtf16String UnescapeC(const TWtringBuf wtr);
-
-/// Returns number of chars in escape sequence.
-///   - 0, if begin >= end
-///   - 1, if [begin, end) starts with an unescaped char
-///   - at least 2 (including '\'), if [begin, end) starts with an escaped symbol
-template <class TChar>
-size_t UnescapeCCharLen(const TChar* begin, const TChar* end);