catboost 1.25.1 → 1.27.0

package/inc/util/generic/cast.h

@@ -1,176 +0,0 @@
-#pragma once
-
-#include "typetraits.h"
-#include "yexception.h"
-#include "type_name.h"
-
-#include <util/system/compat.h>
-#include <util/system/unaligned_mem.h>
-#include <util/system/yassert.h>
-
-#include <cstdlib>
-
-template <class T, class F>
-static inline T VerifyDynamicCast(F f) {
-    if (!f) {
-        return nullptr;
-    }
-
-    T ret = dynamic_cast<T>(f);
-
-    Y_VERIFY(ret, "verify cast failed");
-
-    return ret;
-}
-
-#if !defined(NDEBUG)
-#define USE_DEBUG_CHECKED_CAST
-#endif
-
-namespace NPrivate {
-    template <typename T, typename F>
-    static T DynamicCast(F f) {
-        return dynamic_cast<T>(f);
-    }
-}
-
-/*
- * replacement for dynamic_cast(dynamic_cast in debug mode, else static_cast)
- */
-template <class T, class F>
-static inline T CheckedCast(F f) {
-#if defined(USE_DEBUG_CHECKED_CAST)
-    return VerifyDynamicCast<T>(f);
-#else
-    /* Make sure F is polymorphic.
-     * Without this cast, CheckedCast with non-polymorphic F
-     * incorrectly compiled without error in release mode.
-     */
-    {
-        auto&& x = &::NPrivate::DynamicCast<T, F>;
-
-        (void)x;
-    }
-
-    return static_cast<T>(f);
-#endif // USE_DEBUG_CHECKED_CAST
-}
-
-/*
- * be polite
- */
-#undef USE_DEBUG_CHECKED_CAST
-
-template <bool isUnsigned>
-class TInteger;
-
-template <>
-class TInteger<true> {
-public:
-    template <class TUnsigned>
-    static constexpr bool IsNegative(TUnsigned) noexcept {
-        return false;
-    }
-};
-
-template <>
-class TInteger<false> {
-public:
-    template <class TSigned>
-    static constexpr bool IsNegative(const TSigned value) noexcept {
-        return value < 0;
-    }
-};
-
-template <class TType>
-constexpr bool IsNegative(const TType value) noexcept {
-    return TInteger<std::is_unsigned<TType>::value>::IsNegative(value);
-}
-
-namespace NPrivate {
-    template <class T>
-    using TUnderlyingTypeOrSelf = typename std::conditional<
-        std::is_enum<T>::value,
-        std::underlying_type<T>, // Lazy evaluatuion: do not call ::type here, because underlying_type<T> is undefined if T is not an enum.
-        std::enable_if<true, T>  // Wrapping T in a class, that has member ::type typedef.
-        >::type::type;           // Left ::type is for std::conditional, right ::type is for underlying_type/enable_if
-
-    template <class TSmall, class TLarge>
-    struct TSafelyConvertible {
-        using TSmallInt = TUnderlyingTypeOrSelf<TSmall>;
-        using TLargeInt = TUnderlyingTypeOrSelf<TLarge>;
-
-        static constexpr bool Result = std::is_integral<TSmallInt>::value && std::is_integral<TLargeInt>::value &&
-                                       ((std::is_signed<TSmallInt>::value == std::is_signed<TLargeInt>::value && sizeof(TSmallInt) >= sizeof(TLargeInt)) ||
-                                        (std::is_signed<TSmallInt>::value && sizeof(TSmallInt) > sizeof(TLargeInt)));
-    };
-}
-
-template <class TSmallInt, class TLargeInt>
-constexpr std::enable_if_t< ::NPrivate::TSafelyConvertible<TSmallInt, TLargeInt>::Result, TSmallInt> SafeIntegerCast(TLargeInt largeInt) noexcept {
-    return static_cast<TSmallInt>(largeInt);
-}
-
-template <class TSmall, class TLarge>
-inline std::enable_if_t<!::NPrivate::TSafelyConvertible<TSmall, TLarge>::Result, TSmall> SafeIntegerCast(TLarge largeInt) {
-    using TSmallInt = ::NPrivate::TUnderlyingTypeOrSelf<TSmall>;
-    using TLargeInt = ::NPrivate::TUnderlyingTypeOrSelf<TLarge>;
-
-    if (std::is_unsigned<TSmallInt>::value && std::is_signed<TLargeInt>::value) {
-        if (IsNegative(largeInt)) {
-            ythrow TBadCastException() << "Conversion '" << TypeName<TLarge>() << '{' << TLargeInt(largeInt) << "}' to '"
-                                       << TypeName<TSmallInt>()
-                                       << "', negative value converted to unsigned";
-        }
-    }
-
-    TSmallInt smallInt = TSmallInt(largeInt);
-
-    if (std::is_signed<TSmallInt>::value && std::is_unsigned<TLargeInt>::value) {
-        if (IsNegative(smallInt)) {
-            ythrow TBadCastException() << "Conversion '" << TypeName<TLarge>() << '{' << TLargeInt(largeInt) << "}' to '"
-                                       << TypeName<TSmallInt>()
-                                       << "', positive value converted to negative";
-        }
-    }
-
-    if (TLargeInt(smallInt) != largeInt) {
-        ythrow TBadCastException() << "Conversion '" << TypeName<TLarge>() << '{' << TLargeInt(largeInt) << "}' to '"
-                                   << TypeName<TSmallInt>() << "', loss of data";
-    }
-
-    return static_cast<TSmall>(smallInt);
-}
-
-template <class TSmallInt, class TLargeInt>
-inline TSmallInt IntegerCast(TLargeInt largeInt) noexcept {
-    try {
-        return SafeIntegerCast<TSmallInt>(largeInt);
-    } catch (const yexception& exc) {
-        Y_FAIL("IntegerCast: %s", exc.what());
-    }
-}
-
-/* Convert given enum value to its underlying type. This is just a shortcut for
- * `static_cast<std::underlying_type_t<EEnum>>(enum_)`.
- */
-template <typename T>
-constexpr std::underlying_type_t<T> ToUnderlying(const T enum_) noexcept {
-    return static_cast<std::underlying_type_t<T>>(enum_);
-}
-
-// std::bit_cast from c++20
-template <class TTarget, class TSource>
-TTarget BitCast(const TSource& source) {
-    static_assert(sizeof(TSource) == sizeof(TTarget), "Size mismatch");
-    static_assert(std::is_trivially_copyable<TSource>::value, "TSource is not trivially copyable");
-    static_assert(std::is_trivial<TTarget>::value, "TTarget is not trivial");
-
-    // Support volatile qualifiers.
-    // ReadUnaligned does not work with volatile pointers, so cast away
-    // volatileness beforehand.
-    using TNonvolatileSource = std::remove_volatile_t<TSource>;
-    using TNonvolatileTarget = std::remove_volatile_t<TTarget>;
-
-    return ReadUnaligned<TNonvolatileTarget>(&const_cast<const TNonvolatileSource&>(source));
-}

package/inc/util/generic/deque.h

@@ -1,24 +0,0 @@
-#pragma once
-
-#include "fwd.h"
-
-#include <util/memory/alloc.h>
-
-#include <deque>
-#include <memory>
-#include <initializer_list>
-
-template <class T, class A>
-class TDeque: public std::deque<T, TReboundAllocator<A, T>> {
-    using TBase = std::deque<T, TReboundAllocator<A, T>>;
-public:
-    using TBase::TBase;
-
-    inline yssize_t ysize() const noexcept {
-        return (yssize_t)this->size();
-    }
-
-    inline explicit operator bool() const noexcept {
-        return !this->empty();
-    }
-};

package/inc/util/generic/explicit_type.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#include "typetraits.h"
-
-/**
- * Helper type that can be used as one of the parameters in function declaration
- * to limit the number of types this function can be called with.
- *
- * Example usage:
- * @code
- * void CharOnlyFunction(TExplicitType<char> value);
- * void AnythingFunction(char value);
- *
- * CharOnlyFunction('c'); // Works.
- * CharOnlyFunction(1); // Compilation error.
- * CharOnlyFunction(1ull); // Compilation error.
- *
- * AnythingFunction('c'); // Works.
- * AnythingFunction(1); // Works.
- * AnythingFunction(1ull); // Works.
- * @endcode
- */
-template <class T>
-class TExplicitType {
-public:
-    template <class OtherT>
-    TExplicitType(const OtherT& value, std::enable_if_t<std::is_same<OtherT, T>::value>* = nullptr) noexcept
-        : Value_(value)
-    {
-    }
-
-    const T& Value() const noexcept {
-        return Value_;
-    }
-
-    operator const T&() const noexcept {
-        return Value_;
-    }
-
-private:
-    const T& Value_;
-};

package/inc/util/generic/fastqueue.h

@@ -1,55 +0,0 @@
-#pragma once
-
-#include <util/memory/smallobj.h>
-#include "ptr.h"
-
-template <class T>
-class TFastQueue {
-    struct THelper: public TObjectFromPool<THelper>, public TIntrusiveListItem<THelper> {
-        inline THelper(const T& t)
-            : Obj(t)
-        {
-        }
-
-        T Obj;
-    };
-
-public:
-    inline TFastQueue()
-        : Pool_(TDefaultAllocator::Instance())
-        , Size_(0)
-    {
-    }
-
-    inline void Push(const T& t) {
-        Queue_.PushFront(new (&Pool_) THelper(t));
-        ++Size_;
-    }
-
-    inline T Pop() {
-        Y_ASSERT(!this->Empty());
-
-        THolder<THelper> tmp(Queue_.PopBack());
-        --Size_;
-
-        return tmp->Obj;
-    }
-
-    inline size_t Size() const noexcept {
-        return Size_;
-    }
-
-    Y_PURE_FUNCTION
-    inline bool Empty() const noexcept {
-        return !this->Size();
-    }
-
-    inline explicit operator bool() const noexcept {
-        return !this->Empty();
-    }
-
-private:
-    typename THelper::TPool Pool_;
-    TIntrusiveListWithAutoDelete<THelper, TDelete> Queue_;
-    size_t Size_;
-};

package/inc/util/generic/flags.h

@@ -1,244 +0,0 @@
-#pragma once
-
-#include <type_traits>
-
-#include <util/system/types.h>
-#include <util/generic/typetraits.h>
-#include <util/generic/fwd.h>
-
-class IOutputStream;
-namespace NPrivate {
-    void PrintFlags(IOutputStream& stream, ui64 value, size_t size);
-}
-
-/**
- * `TFlags` wrapper provides a type-safe mechanism for storing OR combinations
- * of enumeration values.
- *
- * This class is intended to be used mainly via helper macros. For example:
- * @code
- * class TAligner {
- * public:
- *     enum EOrientation {
- *         Vertical = 1,
- *         Horizontal = 2
- *     };
- *     Y_DECLARE_FLAGS(EOrientations, EOrientation)
- *
- *     // ...
- * };
- *
- * Y_DECLARE_OPERATORS_FOR_FLAGS(TAligner::EOrientations)
- * @endcode
- */
-template <class Enum>
-class TFlags {
-    static_assert(std::is_enum<Enum>::value, "Expecting an enumeration here.");
-
-public:
-    using TEnum = Enum;
-    using TInt = std::underlying_type_t<Enum>;
-
-    constexpr TFlags(std::nullptr_t = 0)
-        : Value_(0)
-    {
-    }
-
-    constexpr TFlags(Enum value)
-        : Value_(static_cast<TInt>(value))
-    {
-    }
-
-    /* Generated copy/move ctor/assignment are OK. */
-
-    constexpr operator TInt() const {
-        return Value_;
-    }
-
-    constexpr TInt ToBaseType() const {
-        return Value_;
-    }
-
-    constexpr static TFlags FromBaseType(TInt value) {
-        return TFlags(TFlag(value));
-    }
-
-    constexpr friend TFlags operator|(TFlags l, TFlags r) {
-        return TFlags(TFlag(l.Value_ | r.Value_));
-    }
-
-    constexpr friend TFlags operator|(TEnum l, TFlags r) {
-        return TFlags(TFlag(static_cast<TInt>(l) | r.Value_));
-    }
-
-    constexpr friend TFlags operator|(TFlags l, TEnum r) {
-        return TFlags(TFlag(l.Value_ | static_cast<TInt>(r)));
-    }
-
-    constexpr friend TFlags operator^(TFlags l, TFlags r) {
-        return TFlags(TFlag(l.Value_ ^ r.Value_));
-    }
-
-    constexpr friend TFlags
-    operator^(TEnum l, TFlags r) {
-        return TFlags(TFlag(static_cast<TInt>(l) ^ r.Value_));
-    }
-
-    constexpr friend TFlags
-    operator^(TFlags l, TEnum r) {
-        return TFlags(TFlag(l.Value_ ^ static_cast<TInt>(r)));
-    }
-
-    constexpr friend TFlags
-    operator&(TFlags l, TFlags r) {
-        return TFlags(TFlag(l.Value_ & r.Value_));
-    }
-
-    constexpr friend TFlags operator&(TEnum l, TFlags r) {
-        return TFlags(TFlag(static_cast<TInt>(l) & r.Value_));
-    }
-
-    constexpr friend TFlags operator&(TFlags l, TEnum r) {
-        return TFlags(TFlag(l.Value_ & static_cast<TInt>(r)));
-    }
-
-    constexpr friend bool operator==(TFlags l, TFlags r) {
-        return l.Value_ == r.Value_;
-    }
-
-    constexpr friend bool operator==(TEnum l, TFlags r) {
-        return static_cast<TInt>(l) == r.Value_;
-    }
-
-    constexpr friend bool operator==(TFlags l, TEnum r) {
-        return l.Value_ == static_cast<TInt>(r);
-    }
-
-    constexpr friend bool operator!=(TFlags l, TFlags r) {
-        return l.Value_ != r.Value_;
-    }
-
-    constexpr friend bool operator!=(TEnum l, TFlags r) {
-        return static_cast<TInt>(l) != r.Value_;
-    }
-
-    constexpr friend bool operator!=(TFlags l, TEnum r) {
-        return l.Value_ != static_cast<TInt>(r);
-    }
-
-    TFlags& operator&=(TFlags mask) {
-        *this = *this & mask;
-        return *this;
-    }
-
-    TFlags& operator&=(Enum mask) {
-        *this = *this & mask;
-        return *this;
-    }
-
-    TFlags& operator|=(TFlags flags) {
-        *this = *this | flags;
-        return *this;
-    }
-
-    TFlags& operator|=(Enum flags) {
-        *this = *this | flags;
-        return *this;
-    }
-
-    TFlags& operator^=(TFlags flags) {
-        *this = *this ^ flags;
-        return *this;
-    }
-
-    TFlags& operator^=(Enum flags) {
-        *this = *this ^ flags;
-        return *this;
-    }
-
-    constexpr TFlags operator~() const {
-        return TFlags(TFlag(~Value_));
-    }
-
-    constexpr bool operator!() const {
-        return !Value_;
-    }
-
-    constexpr explicit operator bool() const {
-        return Value_;
-    }
-
-    constexpr bool HasFlags(TFlags flags) const {
-        return (Value_ & flags.Value_) == flags.Value_;
-    }
-
-    TFlags RemoveFlags(TFlags flags) {
-        Value_ &= ~flags.Value_;
-        return *this;
-    }
-
-    friend IOutputStream& operator<<(IOutputStream& stream, const TFlags& flags) {
-        ::NPrivate::PrintFlags(stream, static_cast<ui64>(flags.Value_), sizeof(TInt));
-        return stream;
-    }
-
-private:
-    struct TFlag {
-        constexpr TFlag() {
-        }
-        constexpr explicit TFlag(TInt value)
-            : Value(value)
-        {
-        }
-
-        TInt Value = 0;
-    };
-
-    constexpr explicit TFlags(TFlag value)
-        : Value_(value.Value)
-    {
-    }
-
-private:
-    TInt Value_;
-};
-
-template <class T>
-struct TPodTraits<TFlags<T>> {
-    enum {
-        IsPod = TTypeTraits<T>::IsPod
-    };
-};
-
-template <class Enum>
-struct THash<TFlags<Enum>> {
-    size_t operator()(const TFlags<Enum>& flags) const noexcept {
-        return THash<typename TFlags<Enum>::TInt>()(flags);
-    }
-};
-
-/**
- * This macro defines a flags type for the provided enum.
- *
- * @param FLAGS                         Name of the flags type to declare.
- * @param ENUM                          Name of the base enum type to use.
- */
-#define Y_DECLARE_FLAGS(FLAGS, ENUM) \
-    using FLAGS = TFlags<ENUM>;
-
-/**
- * This macro declares global operator functions for enum base of `FLAGS` type.
- * This way operations on individual enum values will provide a type-safe
- * `TFlags` object.
- *
- * @param FLAGS                         Flags type to declare operator for.
- */
-#define Y_DECLARE_OPERATORS_FOR_FLAGS(FLAGS)                           \
-    Y_DECLARE_UNUSED                                                   \
-    constexpr inline FLAGS operator|(FLAGS::TEnum l, FLAGS::TEnum r) { \
-        return FLAGS(l) | r;                                           \
-    }                                                                  \
-    Y_DECLARE_UNUSED                                                   \
-    constexpr inline FLAGS operator~(FLAGS::TEnum value) {             \
-        return ~FLAGS(value);                                          \
-    }

package/inc/util/generic/function.h

@@ -1,103 +0,0 @@
-#pragma once
-
-#include "typetraits.h"
-#include "typelist.h"
-
-#include <functional>
-
-namespace NPrivate {
-    template <class F>
-    struct TRemoveClassImpl {
-        using TSignature = F;
-    };
-
-    template <typename C, typename R, typename... Args>
-    struct TRemoveClassImpl<R (C::*)(Args...)> {
-        typedef R TSignature(Args...);
-    };
-
-    template <typename C, typename R, typename... Args>
-    struct TRemoveClassImpl<R (C::*)(Args...) const> {
-        typedef R TSignature(Args...);
-    };
-
-    template <class T>
-    struct TRemoveNoExceptImpl {
-        using Type = T;
-    };
-
-    template <typename R, typename... Args>
-    struct TRemoveNoExceptImpl<R(Args...) noexcept> {
-        using Type = R(Args...);
-    };
-
-    template <typename R, typename C, typename... Args>
-    struct TRemoveNoExceptImpl<R (C::*)(Args...) noexcept> {
-        using Type = R (C::*)(Args...);
-    };
-
-    template <class T>
-    using TRemoveNoExcept = typename TRemoveNoExceptImpl<T>::Type;
-
-    template <class F>
-    using TRemoveClass = typename TRemoveClassImpl<TRemoveNoExcept<F>>::TSignature;
-
-    template <class C>
-    struct TFuncInfo {
-        using TSignature = TRemoveClass<decltype(&C::operator())>;
-    };
-
-    template <class R, typename... Args>
-    struct TFuncInfo<R(Args...)> {
-        using TResult = R;
-        typedef R TSignature(Args...);
-    };
-}
-
-template <class C>
-using TFunctionSignature = typename ::NPrivate::TFuncInfo< ::NPrivate::TRemoveClass<std::remove_reference_t<std::remove_pointer_t<C>>>>::TSignature;
-
-template <typename F>
-struct TCallableTraits: public TCallableTraits<TFunctionSignature<F>> {
-};
-
-template <typename R, typename... Args>
-struct TCallableTraits<R(Args...)> {
-    using TResult = R;
-    using TArgs = TTypeList<Args...>;
-    typedef R TSignature(Args...);
-};
-
-template <typename C>
-using TFunctionResult = typename TCallableTraits<C>::TResult;
-
-template <typename C>
-using TFunctionArgs = typename TCallableTraits<C>::TArgs;
-
-template <typename C, size_t N>
-struct TFunctionArgImpl {
-    using TArgs = TFunctionArgs<C>;
-    using TResult = typename TArgs::template TGet<N>;
-};
-
-template <typename C, size_t N>
-using TFunctionArg = typename TFunctionArgImpl<C, N>::TResult;
-
-// temporary before std::apply appearance
-
-template <typename F, typename Tuple, size_t... I>
-auto ApplyImpl(F&& f, Tuple&& t, std::index_sequence<I...>) {
-    return f(std::get<I>(std::forward<Tuple>(t))...);
-}
-
-// change to std::apply after c++ 17
-template <typename F, typename Tuple>
-auto Apply(F&& f, Tuple&& t) {
-    return ApplyImpl(f, t, std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{});
-}
-
-// change to std::apply after c++ 17
-template <typename F>
-auto Apply(F&& f, std::tuple<>) {
-    return f();
-}