catboost 1.25.1 → 1.27.0

package/inc/util/generic/is_in.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include "typetraits.h"
-
-#include <algorithm>
-#include <initializer_list>
-
-template <class I, class T>
-static inline bool IsIn(I f, I l, const T& v);
-
-template <class C, class T>
-static inline bool IsIn(const C& c, const T& e);
-
-namespace NIsInHelper {
-    Y_HAS_MEMBER(find, FindMethod);
-    Y_HAS_SUBTYPE(const_iterator, ConstIterator);
-    Y_HAS_SUBTYPE(key_type, KeyType);
-
-    template <class T>
-    using TIsAssocCont = TConjunction<THasFindMethod<T>, THasConstIterator<T>, THasKeyType<T>>;
-
-    template <class C, class T, bool isAssoc>
-    struct TIsInTraits {
-        static bool IsIn(const C& c, const T& e) {
-            using std::begin;
-            using std::end;
-            return ::IsIn(begin(c), end(c), e);
-        }
-    };
-
-    template <class C, class T>
-    struct TIsInTraits<C, T, true> {
-        static bool IsIn(const C& c, const T& e) {
-            return c.find(e) != c.end();
-        }
-    };
-}
-
-template <class I, class T>
-static inline bool IsIn(I f, I l, const T& v) {
-    return std::find(f, l, v) != l;
-}
-
-template <class C, class T>
-static inline bool IsIn(const C& c, const T& e) {
-    using namespace NIsInHelper;
-    return TIsInTraits<C, T, TIsAssocCont<C>::value>::IsIn(c, e);
-}
-
-template <class T, class U>
-static inline bool IsIn(std::initializer_list<T> l, const U& e) {
-    return ::IsIn(l.begin(), l.end(), e);
-}

package/inc/util/generic/iterator.h

@@ -1,137 +0,0 @@
-#pragma once
-
-#include <iterator>
-#include <utility>
-
-namespace NStlIterator {
-    template <class T>
-    class TProxy {
-    public:
-        TProxy() = default;
-        TProxy(T&& value) : Value_(std::move(value)) {
-        }
-
-        const T* operator->() const noexcept {
-            return &Value_;
-        }
-
-        const T& operator*() const noexcept {
-            return Value_;
-        }
-
-        bool operator==(const TProxy& rhs) const {
-            return Value_ == rhs.Value_;
-        }
-
-    private:
-        T Value_;
-    };
-} // namespace NStlIterator
-
-/**
- * Range adaptor that turns a derived class with a Java-style iteration
- * interface into an STL range.
- *
- * Derived class is expected to define:
- * \code
- * TSomething* Next();
- * \endcode
- *
- * `Next()` returning `nullptr` signals end of range. Note that you can also use
- * pointer-like types instead of actual pointers (e.g. `TAtomicSharedPtr`).
- *
- * Since iteration state is stored inside the derived class, the resulting range
- * is an input range (works for single pass algorithms only). Technically speaking,
- * if you're returning a non-const pointer from `Next`, it can also work as an output range.
- *
- * Example usage:
- * \code
- * class TSquaresGenerator: public TInputRangeAdaptor<TSquaresGenerator> {
- * public:
- *     const double* Next() {
- *         Current_ = State_ * State_;
- *         State_ += 1.0;
- *         // Never return nullptr => we have infinite range!
- *         return &Current_;
- *     }
- *
- * private:
- *     double State_ = 0.0;
- *     double Current_ = 0.0;
- * }
- * \endcode
- */
-template <class TSlave>
-class TInputRangeAdaptor {
-public: // TODO: private
-    class TIterator {
-    public:
-        static constexpr bool IsNoexceptNext = noexcept(std::declval<TSlave>().Next());
-
-        using difference_type = std::ptrdiff_t;
-        using pointer = decltype(std::declval<TSlave>().Next());
-        using reference = decltype(*std::declval<TSlave>().Next());
-        using value_type = std::remove_cv_t<std::remove_reference_t<reference>>;
-        using iterator_category = std::input_iterator_tag;
-
-        inline TIterator() noexcept
-            : Slave_(nullptr)
-            , Cur_()
-        {
-        }
-
-        inline TIterator(TSlave* slave) noexcept(IsNoexceptNext)
-            : Slave_(slave)
-            , Cur_(Slave_->Next())
-        {
-        }
-
-        inline bool operator==(const TIterator& it) const noexcept {
-            return Cur_ == it.Cur_;
-        }
-
-        inline bool operator!=(const TIterator& it) const noexcept {
-            return !(*this == it);
-        }
-
-        inline pointer operator->() const noexcept {
-            return Cur_;
-        }
-
-        inline reference operator*() const noexcept {
-            return *Cur_;
-        }
-
-        inline TIterator& operator++() noexcept(IsNoexceptNext) {
-            Cur_ = Slave_->Next();
-
-            return *this;
-        }
-
-    private:
-        TSlave* Slave_;
-        pointer Cur_;
-    };
-
-public:
-    using const_iterator = TIterator;
-    using iterator = const_iterator;
-
-    inline iterator begin() const noexcept(TIterator::IsNoexceptNext) {
-        return TIterator(const_cast<TSlave*>(static_cast<const TSlave*>(this)));
-    }
-
-    inline iterator end() const noexcept {
-        return TIterator();
-    }
-};
-
-/**
- * Transform given reverse iterator into forward iterator pointing to the same element.
- *
- * @see http://stackoverflow.com/a/1830240
- */
-template <class TIterator>
-auto ToForwardIterator(TIterator iter) {
-    return std::next(iter).base();
-}

package/inc/util/generic/iterator_range.h

@@ -1,105 +0,0 @@
-#pragma once
-
-#include <util/system/yassert.h>
-
-#include <iterator>
-#include <utility>
-
-template <typename TBegin, typename TEnd = TBegin>
-struct TIteratorRange {
-    using TElement = std::remove_reference_t<decltype(*std::declval<TBegin>())>;
-
-    TIteratorRange(TBegin begin, TEnd end)
-        : Begin_(begin)
-        , End_(end)
-    {
-    }
-
-    TIteratorRange()
-        : TIteratorRange(TBegin{}, TEnd{})
-    {
-    }
-
-    TBegin begin() const {
-        return Begin_;
-    }
-
-    TEnd end() const {
-        return End_;
-    }
-
-    bool empty() const {
-        // because range based for requires exactly '!='
-        return !(Begin_ != End_);
-    }
-
-private:
-    TBegin Begin_;
-    TEnd End_;
-};
-
-template <class TIterator>
-class TIteratorRange<TIterator, TIterator> {
-public:
-    using iterator = TIterator;
-    using const_iterator = TIterator;
-    using value_type = typename std::iterator_traits<iterator>::value_type;
-    using reference = typename std::iterator_traits<iterator>::reference;
-    using const_reference = typename std::iterator_traits<const_iterator>::reference;
-    using difference_type = typename std::iterator_traits<iterator>::difference_type;
-    using size_type = std::size_t;
-
-    TIteratorRange()
-        : Begin_()
-        , End_()
-    {
-    }
-
-    TIteratorRange(TIterator begin, TIterator end)
-        : Begin_(begin)
-        , End_(end)
-    {
-    }
-
-    TIterator begin() const {
-        return Begin_;
-    }
-
-    TIterator end() const {
-        return End_;
-    }
-
-    Y_PURE_FUNCTION
-    bool empty() const {
-        return Begin_ == End_;
-    }
-
-    size_type size() const {
-        return End_ - Begin_;
-    }
-
-    reference operator[](size_t at) const {
-        Y_ASSERT(at < size());
-
-        return *(Begin_ + at);
-    }
-
-private:
-    TIterator Begin_;
-    TIterator End_;
-};
-
-template <class TIterator>
-TIteratorRange<TIterator> MakeIteratorRange(TIterator begin, TIterator end) {
-    return TIteratorRange<TIterator>(begin, end);
-}
-
-template <class TIterator>
-TIteratorRange<TIterator> MakeIteratorRange(const std::pair<TIterator, TIterator>& range) {
-    return TIteratorRange<TIterator>(range.first, range.second);
-}
-
-template <class TBegin, class TEnd>
-TIteratorRange<TBegin, TEnd> MakeIteratorRange(TBegin begin, TEnd end) {
-    return {begin, end};
-}

package/inc/util/generic/lazy_value.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include "maybe.h"
-#include "function.h"
-
-template <class T>
-class TLazyValueBase {
-public:
-    using TInitializer = std::function<T()>;
-
-    TLazyValueBase() = default;
-
-    TLazyValueBase(TInitializer initializer)
-        : Initializer(std::move(initializer))
-    {
-    }
-
-    explicit operator bool() const noexcept {
-        return Defined();
-    }
-
-    bool Defined() const noexcept {
-        return ValueHolder.Defined();
-    }
-
-    const T& GetRef() const {
-        if (!Defined()) {
-            InitDefault();
-        }
-        return *ValueHolder;
-    }
-
-    const T& operator*() const {
-        return GetRef();
-    }
-
-    const T* operator->() const {
-        return &GetRef();
-    }
-
-    void InitDefault() const {
-        Y_ASSERT(Initializer);
-        ValueHolder = Initializer();
-    }
-
-private:
-    mutable TMaybe<T> ValueHolder;
-    TInitializer Initializer;
-};
-
-// we need this to get implicit construction TLazyValue from lambda
-// and save default copy constructor and operator= for type TLazyValue
-template <class T>
-class TLazyValue: public TLazyValueBase<T> {
-public:
-    template <typename... TArgs>
-    TLazyValue(TArgs&&... args)
-        : TLazyValueBase<T>(std::forward<TArgs>(args)...)
-    {
-    }
-};
-
-template <typename F>
-TLazyValue<TFunctionResult<F>> MakeLazy(F&& f) {
-    return {std::forward<F>(f)};
-}

package/inc/util/generic/list.h

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

package/inc/util/generic/map.h

@@ -1,44 +0,0 @@
-#pragma once
-
-#include "fwd.h"
-#include "mapfindptr.h"
-
-#include <util/str_stl.h>
-#include <util/memory/alloc.h>
-
-#include <utility>
-#include <initializer_list>
-#include <map>
-#include <memory>
-
-template <class K, class V, class Less, class A>
-class TMap: public std::map<K, V, Less, TReboundAllocator<A, std::pair<const K, V>>>, public TMapOps<TMap<K, V, Less, A>> {
-    using TBase = std::map<K, V, Less, TReboundAllocator<A, std::pair<const K, V>>>;
-
-public:
-    using TBase::TBase;
-
-    inline explicit operator bool() const noexcept {
-        return !this->empty();
-    }
-
-    inline bool contains(const K& key) const {
-        return this->find(key) != this->end();
-    }
-};
-
-template <class K, class V, class Less, class A>
-class TMultiMap: public std::multimap<K, V, Less, TReboundAllocator<A, std::pair<const K, V>>> {
-    using TBase = std::multimap<K, V, Less, TReboundAllocator<A, std::pair<const K, V>>>;
-
-public:
-    using TBase::TBase;
-
-    inline explicit operator bool() const noexcept {
-        return !this->empty();
-    }
-
-    inline bool contains(const K& key) const {
-        return this->find(key) != this->end();
-    }
-};

package/inc/util/generic/mapfindptr.h

@@ -1,60 +0,0 @@
-#pragma once
-
-#include <type_traits>
-
-/** MapFindPtr usage:
-
-if (T* value = MapFindPtr(myMap, someKey) {
-    Cout << *value;
-}
-
-*/
-
-template <class Map, class K>
-inline auto MapFindPtr(Map& map, const K& key) {
-    auto i = map.find(key);
-
-    return (i == map.end() ? nullptr : &i->second);
-}
-
-template <class Map, class K>
-inline auto MapFindPtr(const Map& map, const K& key) {
-    auto i = map.find(key);
-
-    return (i == map.end() ? nullptr : &i->second);
-}
-
-/** helper for THashMap/TMap */
-template <class Derived>
-struct TMapOps {
-    template <class K>
-    inline auto FindPtr(const K& key) {
-        return MapFindPtr(static_cast<Derived&>(*this), key);
-    }
-
-    template <class K>
-    inline auto FindPtr(const K& key) const {
-        return MapFindPtr(static_cast<const Derived&>(*this), key);
-    }
-
-    template <class K, class DefaultValue>
-    inline auto Value(const K& key, const DefaultValue& defaultValue) const -> std::remove_reference_t<decltype(*this->FindPtr(key))> {
-        if (auto found = FindPtr(key)) {
-            return *found;
-        }
-        return defaultValue;
-    }
-
-    template <class K, class V>
-    inline const V& ValueRef(const K& key, V& defaultValue) const {
-        static_assert(std::is_same<std::remove_const_t<V>, typename Derived::mapped_type>::value, "Passed default value must have the same type as the underlying map's mapped_type.");
-
-        if (auto found = FindPtr(key)) {
-            return *found;
-        }
-        return defaultValue;
-    }
-
-    template <class K, class V>
-    inline const V& ValueRef(const K& key, V&& defaultValue) const = delete;
-};