catboost 1.25.1 → 1.26.0

package/inc/util/generic/type_name.h

@@ -1,34 +0,0 @@
-#pragma once
-
-#include "string.h"
-
-#include <typeindex>
-#include <typeinfo>
-
-// TypeName function family return human readable type name.
-
-TString TypeName(const std::type_info& typeInfo);
-TString TypeName(const std::type_index& typeInfo);
-
-// Works for types known at compile-time
-// (thus, does not take any inheritance into account)
-template <class T>
-inline TString TypeName() {
-    return TypeName(typeid(T));
-}
-
-// Works for dynamic type, including complex class hierarchies
-// (note that values must be passed by pointer).
-template <class T>
-inline TString TypeName(T* t) {
-    return TypeName(typeid(*t));
-}
-
-// ISO C++ does not allow indirection on operand of type 'void *'
-inline TString TypeName(void*) {
-    return "void";
-}
-
-inline TString TypeName(const void*) {
-    return "const void";
-}

package/inc/util/generic/typelist.h

@@ -1,114 +0,0 @@
-#pragma once
-
-#include <util/system/types.h>
-
-#include <util/generic/typetraits.h>
-
-#include <type_traits>
-
-template <class... R>
-struct TTypeList;
-
-namespace NTL {
-    template <unsigned N, typename TL>
-    struct TGetImpl {
-        using type = typename TGetImpl<N - 1, typename TL::TTail>::type;
-    };
-
-    template <typename TL>
-    struct TGetImpl<0u, TL> {
-        using type = typename TL::THead;
-    };
-}
-
-template <>
-struct TTypeList<> {
-    static constexpr size_t Length = 0;
-
-    template <class>
-    using THave = std::false_type;
-
-    template <template <class> class P>
-    struct TSelectBy {
-        using type = TTypeList<>;
-    };
-};
-
-using TNone = TTypeList<>;
-
-template <class H, class... R>
-struct TTypeList<H, R...> {
-    using THead = H;
-    using TTail = TTypeList<R...>;
-
-    static constexpr size_t Length = 1 + sizeof...(R);
-
-    template <class V>
-    using THave = TDisjunction<std::is_same<H, V>, typename TTail::template THave<V>>;
-
-    template <unsigned N>
-    using TGet = typename ::NTL::TGetImpl<N, TTypeList<H, R...>>::type;
-
-    template <template <class> class P>
-    struct TSelectBy {
-        using type = std::conditional_t<P<THead>::value, THead, typename TTail::template TSelectBy<P>::type>;
-    };
-};
-
-//FIXME: temporary to check overall build
-template <class T>
-struct TTypeList<T, TNone>: public TTypeList<T> {
-};
-
-using TCommonSignedInts = TTypeList<signed char, signed short, signed int, signed long, signed long long>;
-using TCommonUnsignedInts = TTypeList<unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long, bool>;
-using TFixedWidthSignedInts = TTypeList<i8, i16, i32, i64>;
-using TFixedWidthUnsignedInts = TTypeList<ui8, ui16, ui32, ui64>;
-using TFloats = TTypeList<float, double, long double>;
-
-namespace NTL {
-    template <class T1, class T2>
-    struct TConcat;
-
-    template <class... R1, class... R2>
-    struct TConcat<TTypeList<R1...>, TTypeList<R2...>> {
-        using type = TTypeList<R1..., R2...>;
-    };
-
-    template <bool isSigned, class T, class TS, class TU>
-    struct TTypeSelectorBase {
-        using TSignedInts = typename TConcat<TTypeList<T>, TS>::type;
-        using TUnsignedInts = TU;
-    };
-
-    template <class T, class TS, class TU>
-    struct TTypeSelectorBase<false, T, TS, TU> {
-        using TSignedInts = TS;
-        using TUnsignedInts = typename TConcat<TTypeList<T>, TU>::type;
-    };
-
-    template <class T, class TS, class TU>
-    struct TTypeSelector: public TTypeSelectorBase<((T)(-1) < 0), T, TS, TU> {
-    };
-
-    using T1 = TTypeSelector<char, TCommonSignedInts, TCommonUnsignedInts>;
-    using T2 = TTypeSelector<wchar_t, T1::TSignedInts, T1::TUnsignedInts>;
-}
-
-using TSignedInts = NTL::T2::TSignedInts;
-using TUnsignedInts = NTL::T2::TUnsignedInts;
-
-template <unsigned sizeOf>
-struct TSizeOfPredicate {
-    template <class T>
-    using TResult = TBoolConstant<sizeof(T) == sizeOf>;
-};
-
-template <typename T>
-using TFixedWidthSignedInt = typename TFixedWidthSignedInts::template TSelectBy<TSizeOfPredicate<sizeof(T)>::template TResult>::type;
-
-template <typename T>
-using TFixedWidthUnsignedInt = typename TFixedWidthUnsignedInts::template TSelectBy<TSizeOfPredicate<sizeof(T)>::template TResult>::type;
-
-template <typename T>
-using TFixedWidthFloat = typename TFloats::template TSelectBy<TSizeOfPredicate<sizeof(T)>::template TResult>::type;

package/inc/util/generic/typetraits.h

@@ -1,325 +0,0 @@
-#pragma once
-
-#include "va_args.h"
-
-#include <util/system/defaults.h>
-
-#include <iterator>
-#include <type_traits>
-#include <stlfwd>
-
-#if _LIBCPP_STD_VER >= 17
-template <bool B>
-using TBoolConstant = std::bool_constant<B>;
-#else
-template <bool B>
-struct TBoolConstant : std::integral_constant<bool, B> {};
-#endif
-
-#if _LIBCPP_STD_VER >= 17
-template <class B>
-using TNegation = std::negation<B>;
-#else
-template <class B>
-struct TNegation : ::TBoolConstant<!bool(B::value)> {};
-#endif
-
-namespace NPrivate {
-    template <class... Bs>
-    constexpr bool ConjunctionImpl() {
-        bool bs[] = {(bool)Bs::value...};
-        for (auto b : bs) {
-            if (!b) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    template <class... Bs>
-    constexpr bool DisjunctionImpl() {
-        bool bs[] = {(bool)Bs::value...};
-        for (auto b : bs) {
-            if (b) {
-                return true;
-            }
-        }
-        return false;
-    }
-}
-
-#if _LIBCPP_STD_VER >= 17 && !defined(_MSC_VER)
-// Disable std::conjunction for MSVC by analogy with std::disjunction.
-template <class... Bs>
-using TConjunction = std::conjunction<Bs...>;
-#else
-template <class... Bs>
-struct TConjunction : ::TBoolConstant< ::NPrivate::ConjunctionImpl<Bs...>()> {};
-#endif
-
-#if _LIBCPP_STD_VER >= 17 && !defined(_MSC_VER)
-// Disable std::disjunction for MSVC.
-// It reduces build time (500 -> 20 seconds) and memory consumption (20 GB -> less than 1 GB)
-// for some files (notably search/dssm_boosting/dssm_boosting_calcer.cpp).
-template <class... Bs>
-using TDisjunction = std::disjunction<Bs...>;
-#else
-template <class... Bs>
-struct TDisjunction : ::TBoolConstant< ::NPrivate::DisjunctionImpl<Bs...>()> {};
-#endif
-
-#if _LIBCPP_STD_VER >= 17
-template <class... Bs>
-using TVoidT = std::void_t<Bs...>;
-#else
-template <class...>
-using TVoidT = void;
-#endif
-
-template <class T>
-struct TPodTraits {
-    enum {
-        IsPod = false
-    };
-};
-
-template <class T>
-class TTypeTraitsBase {
-public:
-    static constexpr bool IsPod = (
-        TPodTraits<std::remove_cv_t<T>>::IsPod || std::is_scalar<std::remove_all_extents_t<T>>::value ||
-        TPodTraits<std::remove_cv_t<std::remove_all_extents_t<T>>>::IsPod
-    );
-    static constexpr bool IsBitwiseCopyable = std::is_pod<std::remove_cv_t<T>>::value;
-    static constexpr bool IsBitwiseSerializable = std::is_pod<std::remove_cv_t<T>>::value;
-};
-
-namespace NPrivate {
-    template <class T>
-    struct TIsSmall : std::integral_constant<bool, (sizeof(T) <= sizeof(void*))> {};
-}
-
-template <class T>
-class TTypeTraits: public TTypeTraitsBase<T> {
-    using TBase = TTypeTraitsBase<T>;
-
-    /*
-     * can be effectively passed to function as value
-     */
-    static constexpr bool IsValueType = std::is_scalar<T>::value ||
-                                        std::is_array<T>::value ||
-                                        std::is_reference<T>::value ||
-                                        (TBase::IsPod &&
-                                         std::conditional_t<
-                                             std::is_function<T>::value,
-                                             std::false_type,
-                                             ::NPrivate::TIsSmall<T>>::value);
-
-public:
-    /*
-     * can be used in function templates for effective parameters passing
-     */
-    using TFuncParam = std::conditional_t<IsValueType, T, const std::remove_reference_t<T>&>;
-};
-
-template <>
-class TTypeTraits<void>: public TTypeTraitsBase<void> {};
-
-#define Y_DECLARE_PODTYPE(type) \
-    template <>                 \
-    struct TPodTraits<type> {   \
-        enum { IsPod = true };  \
-    }
-
-#define Y_HAS_MEMBER_IMPL_2(method, name)                                                 \
-    template <class T>                                                                    \
-    struct TClassHas##name {                                                              \
-        struct TBase {                                                                    \
-            void method();                                                                \
-        };                                                                                \
-        class THelper: public T, public TBase {                                           \
-        public:                                                                           \
-            template <class T1>                                                           \
-            inline THelper(const T1& = T1()) {                                            \
-            }                                                                             \
-        };                                                                                \
-        template <class T1, T1 val>                                                       \
-        class TChecker {};                                                                \
-        struct TNo {                                                                      \
-            char ch;                                                                      \
-        };                                                                                \
-        struct TYes {                                                                     \
-            char arr[2];                                                                  \
-        };                                                                                \
-        template <class T1>                                                               \
-        static TNo CheckMember(T1*, TChecker<void (TBase::*)(), &T1::method>* = nullptr); \
-        static TYes CheckMember(...);                                                     \
-        static constexpr bool value =                                                     \
-            (sizeof(TYes) == sizeof(CheckMember((THelper*)nullptr)));                     \
-    };                                                                                    \
-    template <class T, bool isClassType>                                                  \
-    struct TBaseHas##name : std::false_type {};                                           \
-    template <class T>                                                                    \
-    struct TBaseHas##name<T, true>                                                        \
-        : std::integral_constant<bool, TClassHas##name<T>::value> {};                     \
-    template <class T>                                                                    \
-    struct THas##name                                                                     \
-        : TBaseHas##name<T, std::is_class<T>::value || std::is_union<T>::value> {}
-
-#define Y_HAS_MEMBER_IMPL_1(name) Y_HAS_MEMBER_IMPL_2(name, name)
-
-/* @def Y_HAS_MEMBER
- *
- * This macro should be used to define compile-time introspection helper classes for template
- * metaprogramming.
- *
- * Macro accept one or two parameters, when used with two parameters e.g. `Y_HAS_MEMBER(xyz, ABC)`
- * will define class `THasABC` with static member `value` of type bool. Usage with one parameter
- * e.g. `Y_HAS_MEMBER(xyz)` will produce the same result as `Y_HAS_MEMBER(xyz, xyz)`.
- *
- * @code
- * #include <type_traits>
- *
- * Y_HAS_MEMBER(push_front, PushFront);
- *
- * template <typename T, typename U>
- * std::enable_if_t<THasPushFront<T>::value, void>
- * PushFront(T& container, const U value) {
- *     container.push_front(x);
- * }
- *
- * template <typename T, typename U>
- * std::enable_if_t<!THasPushFront<T>::value, void>
- * PushFront(T& container, const U value) {
- *     container.insert(container.begin(), x);
- * }
- * @endcode
- */
-#define Y_HAS_MEMBER(...) Y_PASS_VA_ARGS(Y_MACRO_IMPL_DISPATCHER_2(__VA_ARGS__, Y_HAS_MEMBER_IMPL_2, Y_HAS_MEMBER_IMPL_1)(__VA_ARGS__))
-
-#define Y_HAS_SUBTYPE_IMPL_2(subtype, name) \
-    template <class T, class = void>        \
-    struct THas##name : std::false_type {}; \
-    template <class T>                      \
-    struct THas##name<T, ::TVoidT<typename T::subtype>> : std::true_type {};
-
-#define Y_HAS_SUBTYPE_IMPL_1(name) Y_HAS_SUBTYPE_IMPL_2(name, name)
-
-/* @def Y_HAS_SUBTYPE
- *
- * This macro should be used to define compile-time introspection helper classes for template
- * metaprogramming.
- *
- * Macro accept one or two parameters, when used with two parameters e.g. `Y_HAS_SUBTYPE(xyz, ABC)`
- * will define class `THasABC` with static member `value` of type bool. Usage with one parameter
- * e.g. `Y_HAS_SUBTYPE(xyz)` will produce the same result as `Y_HAS_SUBTYPE(xyz, xyz)`.
- *
- * @code
- * Y_HAS_MEMBER(find, FindMethod);
- * Y_HAS_SUBTYPE(const_iterator, ConstIterator);
- * Y_HAS_SUBTYPE(key_type, KeyType);
- *
- * template <typename T>
- * using TIsAssocCont = std::conditional_t<
- *     THasFindMethod<T>::value && THasConstIterator<T>::value && THasKeyType<T>::value,
- *     std::true_type,
- *     std::false_type,
- * >;
- *
- * static_assert(TIsAssocCont<TVector<int>>::value == false, "");
- * static_assert(TIsAssocCont<THashMap<int>>::value == true, "");
- * @endcode
- */
-#define Y_HAS_SUBTYPE(...) Y_PASS_VA_ARGS(Y_MACRO_IMPL_DISPATCHER_2(__VA_ARGS__, Y_HAS_SUBTYPE_IMPL_2, Y_HAS_SUBTYPE_IMPL_1)(__VA_ARGS__))
-
-template <class T1, class T2>
-struct TPodTraits<std::pair<T1, T2>> {
-    enum {
-        IsPod = TTypeTraits<T1>::IsPod && TTypeTraits<T2>::IsPod
-    };
-};
-
-template <class T>
-struct TIsPointerToConstMemberFunction : std::false_type {
-};
-
-template <class R, class T, class... Args>
-struct TIsPointerToConstMemberFunction<R (T::*)(Args...) const> : std::true_type {
-};
-
-template <class R, class T, class... Args>
-struct TIsPointerToConstMemberFunction<R (T::*)(Args...) const&> : std::true_type {
-};
-
-template <class R, class T, class... Args>
-struct TIsPointerToConstMemberFunction<R (T::*)(Args...) const&&> : std::true_type {
-};
-
-template <class R, class T, class... Args>
-struct TIsPointerToConstMemberFunction<R (T::*)(Args..., ...) const> : std::true_type {
-};
-
-template <class R, class T, class... Args>
-struct TIsPointerToConstMemberFunction<R (T::*)(Args..., ...) const&> : std::true_type {
-};
-
-template <class R, class T, class... Args>
-struct TIsPointerToConstMemberFunction<R (T::*)(Args..., ...) const&&> : std::true_type {
-};
-
-template <template <class...> class T, class U>
-struct TIsSpecializationOf : std::false_type {};
-
-template <template <class...> class T, class... Ts>
-struct TIsSpecializationOf<T, T<Ts...>> : std::true_type {};
-
-/*
- * TDependentFalse is a constant dependent on a template parameter.
- * Use it in static_assert in a false branch of if constexpr to produce a compile error.
- * See an example with dependent_false at https://en.cppreference.com/w/cpp/language/if
- *
- * if constexpr (std::is_same<T, someType1>) {
- * } else if constexpr (std::is_same<T, someType2>) {
- * } else {
- *     static_assert(TDependentFalse<T>, "unknown type");
- * }
- */
-template <typename ... T>
-constexpr bool TDependentFalse = false;
-
-// FIXME: neither nvcc10 nor nvcc11 support using auto in this context
-#if defined(__NVCC__)
-template <size_t Value>
-constexpr bool TValueDependentFalse = false;
-#else
-template <auto ... Values>
-constexpr bool TValueDependentFalse = false;
-#endif
-
-/*
- * shortcut for std::enable_if_t<...> which checks that T is std::tuple or std::pair
- */
-template <class T, class R = void>
-using TEnableIfTuple = std::enable_if_t<::TDisjunction<::TIsSpecializationOf<std::tuple, std::decay_t<T>>,
-                                                       ::TIsSpecializationOf<std::pair, std::decay_t<T>>>::value, R>;
-
-
-namespace NPrivate {
-    // To allow ADL with custom begin/end
-    using std::begin;
-    using std::end;
-
-    template <typename T>
-    auto IsIterableImpl(int) -> decltype (
-        begin(std::declval<T&>()) != end(std::declval<T&>()), // begin/end and operator !=
-        ++std::declval<decltype(begin(std::declval<T&>()))&>(), // operator ++
-        *begin(std::declval<T&>()), // operator*
-        std::true_type {}
-    );
-
-    template <typename T>
-    std::false_type IsIterableImpl(...);
-}
-
-template <typename T>
-using TIsIterable = decltype(NPrivate::IsIterableImpl<T>(0));

package/inc/util/generic/utility.h

@@ -1,132 +0,0 @@
-#pragma once
-
-#include "typetraits.h"
-
-#include <cstring>
-
-template <class T>
-static constexpr const T& Min(const T& l, const T& r) {
-    return r < l ? r : l;
-}
-
-template <typename T, typename... Args>
-static constexpr const T& Min(const T& a, const T& b, const Args&... args) {
-    return Min(a, Min(b, args...));
-}
-
-template <class T>
-static constexpr const T& Max(const T& l, const T& r) {
-    return l < r ? r : l;
-}
-
-template <typename T, typename... Args>
-static constexpr const T& Max(const T& a, const T& b, const Args&... args) {
-    return Max(a, Max(b, args...));
-}
-
-// replace with http://en.cppreference.com/w/cpp/algorithm/clamp in c++17
-template <class T>
-constexpr const T& ClampVal(const T& val, const T& min, const T& max) {
-    return val < min ? min : (max < val ? max : val);
-}
-
-template <typename T = double, typename... Args>
-static T Mean(const Args&... other) noexcept {
-    const auto numArgs = sizeof...(other);
-
-    auto sum = T();
-    for (const auto& v : {other...}) {
-        sum += v;
-    }
-
-    return sum / numArgs;
-}
-
-template <class T>
-static inline void Zero(T& t) noexcept {
-    memset((void*)&t, 0, sizeof(t));
-}
-
-/**
- * Securely zero memory (compiler does not optimize this out)
- *
- * @param pointer   void pointer to start of memory block to be zeroed
- * @param count     size of memory block to be zeroed (in bytes)
- */
-void SecureZero(void* pointer, size_t count) noexcept;
-
-/**
- * Securely zero memory of given object (compiler does not optimize this out)
- *
- * @param t     reference to object, which must be zeroed
- */
-template <class T>
-static inline void SecureZero(T& t) noexcept {
-    SecureZero((void*)&t, sizeof(t));
-}
-
-namespace NSwapCheck {
-    Y_HAS_MEMBER(swap);
-    Y_HAS_MEMBER(Swap);
-
-    template <class T, class = void>
-    struct TSwapSelector {
-        static inline void Swap(T& l, T& r) noexcept(std::is_nothrow_move_constructible<T>::value&&
-                                                         std::is_nothrow_move_assignable<T>::value) {
-            T tmp(std::move(l));
-            l = std::move(r);
-            r = std::move(tmp);
-        }
-    };
-
-    template <class T>
-    struct TSwapSelector<T, std::enable_if_t<THasSwap<T>::value>> {
-        static inline void Swap(T& l, T& r) noexcept(noexcept(l.Swap(r))) {
-            l.Swap(r);
-        }
-    };
-
-    template <class T>
-    struct TSwapSelector<T, std::enable_if_t<THasswap<T>::value && !THasSwap<T>::value>> {
-        static inline void Swap(T& l, T& r) noexcept(noexcept(l.swap(r))) {
-            l.swap(r);
-        }
-    };
-}
-
-/*
- * DoSwap better than ::Swap in member functions...
- */
-template <class T>
-static inline void DoSwap(T& l, T& r) noexcept(noexcept(NSwapCheck::TSwapSelector<T>::Swap(l, r))) {
-    NSwapCheck::TSwapSelector<T>::Swap(l, r);
-}
-
-template <bool b>
-struct TNullTmpl {
-    template <class T>
-    operator T() const {
-        return (T)0;
-    }
-};
-
-using TNull = TNullTmpl<0>;
-
-/*
- * Class for zero-initialize padding bytes in derived classes
- */
-template <typename TDerived>
-class TZeroInit {
-protected:
-    TZeroInit() {
-        // Actually, safe because this as TDerived is not initialized yet.
-        Zero(*static_cast<TDerived*>(this));
-    }
-};
-
-struct TIdentity {
-    template <class T>
-    constexpr decltype(auto) operator()(T&& x) const noexcept {
-        return std::forward<T>(x);
-    }
-};