catboost 1.25.1 → 1.27.0

package/inc/util/generic/variant_traits.h

@@ -1,171 +0,0 @@
-#pragma once
-
-#include "typetraits.h"
-#include "yexception.h"
-
-#include <utility>
-#include <type_traits>
-
-template <class... Ts>
-class TVariant;
-
-class TWrongVariantError: public yexception {};
-
-namespace NVariant {
-    template <size_t I, class T>
-    struct TIndexedType {
-        static constexpr size_t value = I;
-        using type = T;
-    };
-
-    template <class, class... Ts>
-    struct TIndexedTypesImpl;
-
-    template <std::size_t... Is, class... Ts>
-    struct TIndexedTypesImpl<std::index_sequence<Is...>, Ts...> {
-        struct type : TIndexedType<Is, Ts>... {};
-    };
-
-    template <class... Ts>
-    using TIndexedTypes = typename TIndexedTypesImpl<std::index_sequence_for<Ts...>, Ts...>::type;
-
-    template <size_t I, class T>
-    constexpr auto GetIndexedType(TIndexedType<I, T> t) {
-        return t;
-    }
-
-    template <size_t I, class... Ts>
-    struct TTypeByIndex {
-        using TTypeImpl = decltype(GetIndexedType<I>(TIndexedTypes<Ts...>{})); // MSVC workaround
-        using type = typename TTypeImpl::type;
-    };
-
-    template <size_t I, class... Ts>
-    using TTypeByIndexType = typename TTypeByIndex<I, Ts...>::type;
-
-    template <size_t I, class V>
-    struct TAlternative;
-
-    template <size_t I, class... Ts>
-    struct TAlternative<I, TVariant<Ts...>> {
-        using type = TTypeByIndexType<I, Ts...>;
-    };
-
-    template <size_t I, class V>
-    using TAlternativeType = typename TAlternative<I, V>::type;
-
-    template <class V>
-    struct TSize;
-
-    template <class... Ts>
-    struct TSize<TVariant<Ts...>> : std::integral_constant<size_t, sizeof...(Ts)> {};
-
-    struct TVariantAccessor {
-        template <size_t I, class... Ts>
-        static TAlternativeType<I, TVariant<Ts...>>& Get(TVariant<Ts...>& v);
-
-        template <size_t I, class... Ts>
-        static const TAlternativeType<I, TVariant<Ts...>>& Get(const TVariant<Ts...>& v);
-
-        template <size_t I, class... Ts>
-        static TAlternativeType<I, TVariant<Ts...>>&& Get(TVariant<Ts...>&& v);
-
-        template <size_t I, class... Ts>
-        static const TAlternativeType<I, TVariant<Ts...>>&& Get(const TVariant<Ts...>&& v);
-
-        template <class... Ts>
-        static constexpr size_t Index(const TVariant<Ts...>& v) noexcept;
-    };
-
-    constexpr size_t T_NPOS = -1;
-
-    template <class X, class... Ts>
-    constexpr size_t IndexOfImpl() {
-        bool bs[] = {std::is_same<X, Ts>::value...};
-        for (size_t i = 0; i < sizeof...(Ts); ++i) {
-            if (bs[i]) {
-                return i;
-            }
-        }
-        return T_NPOS;
-    }
-
-    template <class X, class... Ts>
-    struct TIndexOf : std::integral_constant<size_t, IndexOfImpl<X, Ts...>()> {};
-
-    template <class X, class V>
-    struct TAlternativeIndex;
-
-    template <class X, class... Ts>
-    struct TAlternativeIndex<X, TVariant<Ts...>> : TIndexOf<X, Ts...> {};
-
-    template <class... Ts>
-    struct TTypeTraits {
-        using TNoRefs = TConjunction<TNegation<std::is_reference<Ts>>...>;
-        using TNoVoids = TConjunction<TNegation<std::is_same<Ts, void>>...>;
-        using TNoArrays = TConjunction<TNegation<std::is_array<Ts>>...>;
-        using TNotEmpty = std::integral_constant<bool, (sizeof...(Ts) > 0)>;
-    };
-
-    template <class FRef, class VRef, size_t I = 0>
-    using TReturnType = decltype(
-        std::declval<FRef>()(TVariantAccessor::Get<I>(std::declval<VRef>())));
-
-    template <class FRef, class VRef, size_t... Is>
-    constexpr bool CheckReturnTypes(std::index_sequence<Is...>) {
-        using R = TReturnType<FRef, VRef>;
-        return TConjunction<std::is_same<R, TReturnType<FRef, VRef, Is>>...>::value;
-    }
-
-    template <class ReturnType, size_t I, class FRef, class VRef>
-    ReturnType VisitImplImpl(FRef f, VRef v) {
-        return std::forward<FRef>(f)(TVariantAccessor::Get<I>(std::forward<VRef>(v)));
-    }
-
-    template <class ReturnType, class FRef, class VRef>
-    ReturnType VisitImplFail(FRef, VRef) {
-        throw TWrongVariantError{};
-    }
-
-    template <class F, class V, size_t... Is>
-    decltype(auto) VisitImpl(F&& f, V&& v, std::index_sequence<Is...>) {
-        using FRef = decltype(std::forward<F>(f));
-        using VRef = decltype(std::forward<V>(v));
-        using ReturnType = TReturnType<FRef, VRef>;
-        using LambdaType = ReturnType (*)(FRef, VRef);
-        static constexpr LambdaType handlers[] = {
-            VisitImplImpl<ReturnType, Is, FRef, VRef>...,
-            VisitImplFail<ReturnType, FRef, VRef>};
-        return handlers[TVariantAccessor::Index(v)](std::forward<F>(f), std::forward<V>(v));
-    }
-
-    template <class F, class V>
-    void VisitWrapForVoid(F&& f, V&& v, std::true_type) {
-        // We need to make special wrapper when return type equals void
-        auto l = [&](auto&& x) {
-            std::forward<F>(f)(std::forward<decltype(x)>(x));
-            return 0;
-        };
-        VisitImpl(l, std::forward<V>(v), std::make_index_sequence<TSize<std::decay_t<V>>::value>{});
-    }
-
-    template <class F, class V>
-    decltype(auto) VisitWrapForVoid(F&& f, V&& v, std::false_type) {
-        return VisitImpl(std::forward<F>(f),
-                         std::forward<V>(v),
-                         std::make_index_sequence<TSize<std::decay_t<V>>::value>{});
-    }
-
-    // Can be simplified with c++17: IGNIETFERRO-982
-    template <class Ret, class F, class T, class U>
-    std::enable_if_t<std::is_same<std::decay_t<T>, std::decay_t<U>>::value,
-    Ret> CallIfSame(F f, T&& a, U&& b) {
-        return f(std::forward<T>(a), std::forward<U>(b));
-    }
-
-    template <class Ret, class F, class T, class U>
-    std::enable_if_t<!std::is_same<std::decay_t<T>, std::decay_t<U>>::value,
-    Ret> CallIfSame(F, T&&, U&&) { // Will never be called
-        Y_FAIL();
-    }
-}

package/inc/util/generic/vector.h

@@ -1,119 +0,0 @@
-#pragma once
-
-#include "fwd.h"
-#include "reserve.h"
-
-#include <util/memory/alloc.h>
-
-#include <vector>
-#include <initializer_list>
-
-template <class T, class A>
-class TVector: public std::vector<T, TReboundAllocator<A, T>> {
-public:
-    using TBase = std::vector<T, TReboundAllocator<A, T>>;
-    using TSelf = TVector<T, A>;
-    using size_type = typename TBase::size_type;
-
-    inline TVector()
-        : TBase()
-    {
-    }
-
-    inline TVector(const typename TBase::allocator_type& a)
-        : TBase(a)
-    {
-    }
-
-    inline explicit TVector(::NDetail::TReserveTag rt)
-        : TBase()
-    {
-        this->reserve(rt.Capacity);
-    }
-
-    inline explicit TVector(::NDetail::TReserveTag rt, const typename TBase::allocator_type& a)
-        : TBase(a)
-    {
-        this->reserve(rt.Capacity);
-    }
-
-    inline explicit TVector(size_type count)
-        : TBase(count)
-    {
-    }
-
-    inline explicit TVector(size_type count, const typename TBase::allocator_type& a)
-        : TBase(count, a)
-    {
-    }
-
-    inline TVector(size_type count, const T& val)
-        : TBase(count, val)
-    {
-    }
-
-    inline TVector(size_type count, const T& val, const typename TBase::allocator_type& a)
-        : TBase(count, val, a)
-    {
-    }
-
-    inline TVector(std::initializer_list<T> il)
-        : TBase(il)
-    {
-    }
-
-    inline TVector(std::initializer_list<T> il, const typename TBase::allocator_type& a)
-        : TBase(il, a)
-    {
-    }
-
-    inline TVector(const TSelf& src)
-        : TBase(src)
-    {
-    }
-
-    inline TVector(TSelf&& src) noexcept
-        : TBase(std::forward<TSelf>(src))
-    {
-    }
-
-    template <class TIter>
-    inline TVector(TIter first, TIter last)
-        : TBase(first, last)
-    {
-    }
-
-    inline TSelf& operator=(const TSelf& src) {
-        TBase::operator=(src);
-        return *this;
-    }
-
-    inline TSelf& operator=(TSelf&& src) noexcept {
-        TBase::operator=(std::forward<TSelf>(src));
-        return *this;
-    }
-
-    inline TSelf& operator=(std::initializer_list<T> il) {
-        this->assign(il.begin(), il.end());
-        return *this;
-    }
-
-    inline explicit operator bool() const noexcept {
-        return !this->empty();
-    }
-
-    Y_PURE_FUNCTION
-    inline bool empty() const noexcept {
-        return TBase::empty();
-    }
-
-    inline yssize_t ysize() const noexcept {
-        return (yssize_t)TBase::size();
-    }
-
-    inline void crop(size_type size) {
-        if (this->size() > size) {
-            this->erase(this->begin() + size, this->end());
-        }
-    }
-};

package/inc/util/generic/xrange.h

@@ -1,258 +0,0 @@
-#pragma once
-
-#include "typetraits.h"
-#include "utility.h"
-#include <util/system/yassert.h>
-#include <iterator>
-
-/** @file
- * Some similar for python xrange(): https://docs.python.org/2/library/functions.html#xrange
- * Discussion: https://clubs.at.yandex-team.ru/arcadia/6124
- *
- * Example usage:
- *  for (auto i: xrange(MyVector.size())) { // instead for (size_t i = 0; i < MyVector.size(); ++i)
- *      DoSomething(i, MyVector[i]);
- *  }
- *
- * TVector<int> arithmeticSeq = xrange(10); // instead: TVector<int> arithmeticSeq; for(size_t i = 0; i < 10; ++i) { arithmeticSeq.push_back(i); }
- *
- */
-
-namespace NPrivate {
-    template <typename T>
-    class TSimpleXRange {
-        using TDiff = decltype(T() - T());
-
-    public:
-        constexpr TSimpleXRange(T start, T finish) noexcept
-            : Start(start)
-            , Finish(Max(start, finish))
-        {
-        }
-
-        class TIterator {
-        public:
-            using value_type = T;
-            using difference_type = TDiff;
-            using pointer = const T*;
-            using reference = const T&;
-            using iterator_category = std::random_access_iterator_tag;
-
-            constexpr TIterator(T value) noexcept
-                : Value(value)
-            {
-            }
-
-            constexpr T operator*() const noexcept {
-                return Value;
-            }
-
-            constexpr bool operator!=(const TIterator& other) const noexcept {
-                return Value != other.Value;
-            }
-
-            constexpr bool operator==(const TIterator& other) const noexcept {
-                return Value == other.Value;
-            }
-
-            TIterator& operator++() noexcept {
-                ++Value;
-                return *this;
-            }
-
-            constexpr TDiff operator-(const TIterator& b) const noexcept {
-                return Value - b.Value;
-            }
-
-            template <typename IntType>
-            constexpr TIterator operator+(const IntType& b) const noexcept {
-                return TIterator(Value + b);
-            }
-
-            template <typename IntType>
-            TIterator& operator+=(const IntType& b) noexcept {
-                Value += b;
-                return *this;
-            }
-
-            template <typename IntType>
-            constexpr TIterator operator-(const IntType& b) const noexcept {
-                return TIterator(Value - b);
-            }
-
-            template <typename IntType>
-            TIterator& operator-=(const IntType& b) noexcept {
-                Value -= b;
-                return *this;
-            }
-
-            constexpr bool operator<(const TIterator& b) const noexcept {
-                return Value < b.Value;
-            }
-
-        private:
-            T Value;
-        };
-
-        using value_type = T;
-        using iterator = TIterator;
-        using const_iterator = TIterator;
-
-        constexpr TIterator begin() const noexcept {
-            return TIterator(Start);
-        }
-
-        constexpr TIterator end() const noexcept {
-            return TIterator(Finish);
-        }
-
-        constexpr T size() const noexcept {
-            return Finish - Start;
-        }
-
-        template <class Container>
-        operator Container() const {
-            return Container(begin(), end());
-        }
-
-    private:
-        T Start;
-        T Finish;
-    };
-
-    template <typename T>
-    class TSteppedXRange {
-        using TDiff = decltype(T() - T());
-
-    public:
-        constexpr TSteppedXRange(T start, T finish, TDiff step) noexcept
-            : Start_(start)
-            , Step_(step)
-            , Finish_(CalcRealFinish(Start_, finish, Step_))
-        {
-            static_assert(std::is_integral<T>::value || std::is_pointer<T>::value, "T should be integral type or pointer");
-        }
-
-        class TIterator {
-        public:
-            using value_type = T;
-            using difference_type = TDiff;
-            using pointer = const T*;
-            using reference = const T&;
-            using iterator_category = std::random_access_iterator_tag;
-
-            constexpr TIterator(T value, const TSteppedXRange& parent) noexcept
-                : Value_(value)
-                , Parent_(&parent)
-            {
-            }
-
-            constexpr T operator*() const noexcept {
-                return Value_;
-            }
-
-            constexpr bool operator!=(const TIterator& other) const noexcept {
-                return Value_ != other.Value_;
-            }
-
-            constexpr bool operator==(const TIterator& other) const noexcept {
-                return Value_ == other.Value_;
-            }
-
-            TIterator& operator++() noexcept {
-                Value_ += Parent_->Step_;
-                return *this;
-            }
-
-            constexpr TDiff operator-(const TIterator& b) const noexcept {
-                return (Value_ - b.Value_) / Parent_->Step_;
-            }
-
-            template <typename IntType>
-            constexpr TIterator operator+(const IntType& b) const noexcept {
-                return TIterator(*this) += b;
-            }
-
-            template <typename IntType>
-            TIterator& operator+=(const IntType& b) noexcept {
-                Value_ += b * Parent_->Step_;
-                return *this;
-            }
-
-            template <typename IntType>
-            constexpr TIterator operator-(const IntType& b) const noexcept {
-                return TIterator(*this) -= b;
-            }
-
-            template <typename IntType>
-            TIterator& operator-=(const IntType& b) noexcept {
-                Value_ -= b * Parent_->Step_;
-                return *this;
-            }
-
-        private:
-            T Value_;
-            const TSteppedXRange* Parent_;
-        };
-
-        using value_type = T;
-        using iterator = TIterator;
-        using const_iterator = TIterator;
-
-        constexpr TIterator begin() const noexcept {
-            return TIterator(Start_, *this);
-        }
-
-        constexpr TIterator end() const noexcept {
-            return TIterator(Finish_, *this);
-        }
-
-        static T CalcRealFinish(T start, T expFinish, TDiff step) {
-            Y_ASSERT(step != 0);
-            if (step > 0) {
-                if (expFinish > start) {
-                    return start + step * ((expFinish - 1 - start) / step + 1);
-                }
-                return start;
-            }
-            return start - TSteppedXRange<TDiff>::CalcRealFinish(0, start - expFinish, -step);
-        }
-
-        constexpr T size() const noexcept {
-            return (Finish_ - Start_) / Step_;
-        }
-
-        template <class Container>
-        operator Container() const {
-            return Container(begin(), end());
-        }
-
-    private:
-        const T Start_;
-        const TDiff Step_;
-        const T Finish_;
-    };
-
-}
-
-/**
- * generate arithmetic progression that starts at start with certain step and stop at finish (not including)
- *
- * @param step must be non-zero
- */
-template <typename T>
-constexpr ::NPrivate::TSteppedXRange<T> xrange(T start, T finish, decltype(T() - T()) step) noexcept {
-    return {start, finish, step};
-}
-
-/// generate sequence [start; finish)
-template <typename T>
-constexpr ::NPrivate::TSimpleXRange<T> xrange(T start, T finish) noexcept {
-    return {start, finish};
-}
-
-/// generate sequence [0; finish)
-template <typename T>
-constexpr auto xrange(T finish) noexcept -> decltype(xrange(T(), finish)) {
-    return xrange(T(), finish);
-}