catboost 1.25.1 → 1.26.0

package/inc/util/string/hex.h

@@ -1,59 +0,0 @@
-#pragma once
-
-#include <util/generic/string.h>
-#include <util/generic/yexception.h>
-#include <util/system/yassert.h>
-
-inline static char DigitToChar(unsigned char digit) {
-    if (digit < 10) {
-        return (char)digit + '0';
-    }
-
-    return (char)(digit - 10) + 'A';
-}
-
-extern const char* const Char2DigitTable;
-
-inline static int Char2Digit(char ch) {
-    char result = Char2DigitTable[(unsigned char)ch];
-    Y_ENSURE(result != '\xff', "invalid hex character " << (int)ch);
-    return result;
-}
-
-//! Convert a hex string of exactly 2 chars to int
-/*! @example String2Byte("10") => 16 */
-inline static int String2Byte(const char* s) {
-    return Char2Digit(*s) * 16 + Char2Digit(*(s + 1));
-}
-
-char* HexEncode(const void* in, size_t len, char* out);
-
-TString HexEncode(const void* in, size_t len);
-
-inline TString HexEncode(const TStringBuf h) {
-    return HexEncode(h.data(), h.size());
-}
-
-//! Convert a hex string @c in of @c len chars (case-insensitive) to array of ints stored at @c ptr and return this array.
-/*! @note len must be even (len % 2 == 0), otherwise an exception will be thrown.
- *  @return @c ptr, which is an array of chars, where each char holds the numeric value
- *          equal to the corresponding 2 digits of the input stream.
- *  @warning You must ensure that @c ptr has (len/2) allocated bytes, otherwise SIGSEGV will happen.
- *
- * @example HexDecode("beef", 4, ptr) => {190, 239}
- */
-void* HexDecode(const void* in, size_t len, void* ptr);
-
-//! Convert a hex string @c in of @c len chars (case-insensitive) to array of ints and return this array.
-/*! @note len must be even (len % 2 == 0), otherwise an exception will be thrown.
- *  @return an array of chars, where each char holds the numeric value equal to the corresponding 2 digits
- *          of the input stream.
- *
- * @example HexDecode("beef", 4) => {190, 239}
- */
-TString HexDecode(const void* in, size_t len);
-
-//! Convert an ASCII hex-string (case-insensitive) to the binary form. Note that h.Size() must be even (+h % 2 == 0).
-inline TString HexDecode(const TStringBuf h) {
-    return HexDecode(h.data(), h.size());
-}

package/inc/util/string/join.h

@@ -1,194 +0,0 @@
-#pragma once
-
-#include <util/generic/string.h>
-#include <util/generic/typetraits.h>
-#include <util/string/cast.h>
-#include "cast.h"
-
-/*
- * Default implementation of AppendToString uses a temporary TString object which is inefficient. You can overload it
- * for your type to speed up string joins. If you already have an Out() or operator<<() implementation you can simply
- * do the following:
- *
- *      inline void AppendToString(TString& dst, const TMyType& t) {
- *          TStringOutput o(dst);
- *          o << t;
- *      }
- *
- * Unfortunately we can't do this by default because for some types ToString() is defined while Out() is not.
- * For standard types (strings of all kinds and arithmetic types) we don't use a temporary TString in AppendToString().
- */
-
-template <typename T>
-inline std::enable_if_t<!std::is_arithmetic<std::remove_cv_t<T>>::value, void>
-AppendToString(TString& dst, const T& t) {
-    dst.AppendNoAlias(ToString(t));
-}
-
-template <typename T>
-inline std::enable_if_t<std::is_arithmetic<std::remove_cv_t<T>>::value, void>
-AppendToString(TString& dst, const T& t) {
-    char buf[512];
-    dst.append(buf, ToString<std::remove_cv_t<T>>(t, buf, sizeof(buf)));
-}
-
-inline void AppendToString(TString& dst, const char* t) {
-    dst.append(t);
-}
-
-inline void AppendToString(TString& dst, const TStringBuf t) {
-    dst.append(t);
-}
-
-namespace NPrivate {
-    template <typename T>
-    inline size_t GetLength(const T&) {
-        // By default don't pre-allocate space when joining and appending non-string types.
-        // This code can be extended by estimating stringified length for specific types (e.g. 10 for ui32).
-        return 0;
-    }
-
-    template <>
-    inline size_t GetLength(const TString& s) {
-        return s.length();
-    }
-
-    template <>
-    inline size_t GetLength(const TStringBuf& s) {
-        return s.length();
-    }
-
-    template <>
-    inline size_t GetLength(const char* const& s) {
-        return (s ? std::char_traits<char>::length(s) : 0);
-    }
-
-    inline size_t GetAppendLength(const TStringBuf /*delim*/) {
-        return 0;
-    }
-
-    template <typename TFirst, typename... TRest>
-    size_t GetAppendLength(const TStringBuf delim, const TFirst& f, const TRest&... r) {
-        return delim.length() + ::NPrivate::GetLength(f) + ::NPrivate::GetAppendLength(delim, r...);
-    }
-}
-
-inline void AppendJoinNoReserve(TString&, const TStringBuf) {
-}
-
-template <typename TFirst, typename... TRest>
-inline void AppendJoinNoReserve(TString& dst, const TStringBuf delim, const TFirst& f, const TRest&... r) {
-    AppendToString(dst, delim);
-    AppendToString(dst, f);
-    AppendJoinNoReserve(dst, delim, r...);
-}
-
-template <typename... TValues>
-inline void AppendJoin(TString& dst, const TStringBuf delim, const TValues&... values) {
-    const size_t appendLength = ::NPrivate::GetAppendLength(delim, values...);
-    if (appendLength > 0) {
-        dst.reserve(dst.length() + appendLength);
-    }
-    AppendJoinNoReserve(dst, delim, values...);
-}
-
-template <typename TFirst, typename... TRest>
-inline TString Join(const TStringBuf delim, const TFirst& f, const TRest&... r) {
-    TString ret = ToString(f);
-    AppendJoin(ret, delim, r...);
-    return ret;
-}
-
-// Note that char delimeter @cdelim will be printed as single char string,
-// but any char value @v will be printed as corresponding numeric code.
-// For example, Join('a', 'a', 'a') will print "97a97" (see unit-test).
-template <typename... TValues>
-inline TString Join(char cdelim, const TValues&... v) {
-    return Join(TStringBuf(&cdelim, 1), v...);
-}
-
-template <typename TIter>
-inline TString JoinRange(const TStringBuf delim, const TIter beg, const TIter end) {
-    TString out;
-    if (beg != end) {
-        size_t total = ::NPrivate::GetLength(*beg);
-        for (TIter pos = beg; ++pos != end;) {
-            total += delim.length() + ::NPrivate::GetLength(*pos);
-        }
-        if (total > 0) {
-            out.reserve(total);
-        }
-
-        AppendToString(out, *beg);
-        for (TIter pos = beg; ++pos != end;) {
-            AppendJoinNoReserve(out, delim, *pos);
-        }
-    }
-
-    return out;
-}
-
-template <typename TContainer>
-TString JoinSeq(const TStringBuf delim, const TContainer& data) {
-    using std::begin;
-    using std::end;
-    return JoinRange(delim, begin(data), end(data));
-}
-
-/** \brief Functor for streaming iterative objects from TIterB e to TIterE b, separated with delim.
- *         Difference from JoinSeq, JoinRange, Join is the lack of TString object - all depends on operator<< for the type and
- *         realization of IOutputStream
- */
-template<class TIterB, class TIterE>
-struct TRangeJoiner{
-    friend constexpr IOutputStream& operator<<(IOutputStream& stream, const TRangeJoiner<TIterB, TIterE>& rangeJoiner) {
-        if(rangeJoiner.b != rangeJoiner.e) {
-            stream << *rangeJoiner.b;
-
-            for(auto it = std::next(rangeJoiner.b); it != rangeJoiner.e; ++it)
-                stream << rangeJoiner.delim << *it;
-        }
-        return stream;
-    }
-
-    constexpr TRangeJoiner(TStringBuf delim, TIterB && b, TIterE && e) : delim(delim), b(std::forward<TIterB>(b)), e(std::forward<TIterE>(e)) {}
-private:
-    const TStringBuf delim;
-    const TIterB b;
-    const TIterE e;
-};
-
-template<class TIterB, class TIterE = TIterB> constexpr auto MakeRangeJoiner(TStringBuf delim, TIterB && b, TIterE && e) {
-    return TRangeJoiner<TIterB, TIterE>(delim, std::forward<TIterB>(b), std::forward<TIterE>(e));
-}
-
-template<class TContainer> constexpr auto MakeRangeJoiner(TStringBuf delim, const TContainer& data) {
-    return MakeRangeJoiner(delim, std::cbegin(data), std::cend(data));
-}
-
-template<class TVal> constexpr auto MakeRangeJoiner(TStringBuf delim, const std::initializer_list<TVal>& data) {
-    return MakeRangeJoiner(delim, std::cbegin(data), std::cend(data));
-}
-
-/* We force (std::initializer_list<TStringBuf>) input type for (TString) and (const char*) types because:
- * # When (std::initializer_list<TString>) is used, TString objects are copied into the initializer_list object.
- *   Storing TStringBufs instead is faster, even with COW-enabled strings.
- * # For (const char*) we calculate length only once and store it in TStringBuf. Otherwise strlen scan would be executed
- *   in both GetAppendLength and AppendToString. For string literals constant lengths get propagated in compile-time.
- *
- * This way JoinSeq(",", { s1, s2 }) always does the right thing whatever types s1 and s2 have.
- *
- * If someone needs to join std::initializer_list<TString> -- it still works because of the TContainer template above.
-*/
-
-template <typename T>
-inline std::enable_if_t<
-    !std::is_same<std::decay_t<T>, TString>::value && !std::is_same<std::decay_t<T>, const char*>::value,
-    TString>
-JoinSeq(const TStringBuf delim, const std::initializer_list<T>& data) {
-    return JoinRange(delim, data.begin(), data.end());
-}
-
-inline TString JoinSeq(const TStringBuf delim, const std::initializer_list<TStringBuf>& data) {
-    return JoinRange(delim, data.begin(), data.end());
-}

package/inc/util/string/printf.h

@@ -1,13 +0,0 @@
-#pragma once
-
-#include <util/generic/fwd.h>
-#include <util/system/compiler.h>
-
-#include <cstdarg>
-
-/// formatted print. return printed length:
-int Y_PRINTF_FORMAT(2, 0) vsprintf(TString& s, const char* c, va_list params);
-/// formatted print. return printed length:
-int Y_PRINTF_FORMAT(2, 3) sprintf(TString& s, const char* c, ...);
-TString Y_PRINTF_FORMAT(1, 2) Sprintf(const char* c, ...);
-int Y_PRINTF_FORMAT(2, 3) fcat(TString& s, const char* c, ...);

package/inc/util/string/reverse.h

@@ -1,16 +0,0 @@
-#pragma once
-
-#include <util/generic/fwd.h>
-
-void ReverseInPlace(TString& string);
-
-/** NB. UTF-16 is variable-length encoding because of the surrogate pairs.
-  * This function takes this into account and treats a surrogate pair as a single symbol.
-  * Ex. if [C D] is a surrogate pair,
-  * A B [C D] E
-  * will become
-  * E [C D] B A
-  */
-void ReverseInPlace(TUtf16String& string);
-
-void ReverseInPlace(TUtf32String& string);