catboost 1.25.1 → 1.27.0

package/inc/util/generic/queue.h

@@ -1,57 +0,0 @@
-#pragma once
-
-#include "fwd.h"
-#include "deque.h"
-#include "vector.h"
-#include "utility.h"
-
-#include <util/str_stl.h>
-
-#include <queue>
-
-template <class T, class S>
-class TQueue: public std::queue<T, S> {
-    using TBase = std::queue<T, S>;
-
-public:
-    using TBase::TBase;
-
-    inline explicit operator bool() const noexcept {
-        return !this->empty();
-    }
-
-    inline void clear() {
-        this->c.clear();
-    }
-
-    inline S& Container() {
-        return this->c;
-    }
-
-    inline const S& Container() const {
-        return this->c;
-    }
-};
-
-template <class T, class S, class C>
-class TPriorityQueue: public std::priority_queue<T, S, C> {
-    using TBase = std::priority_queue<T, S, C>;
-public:
-    using TBase::TBase;
-
-    inline explicit operator bool() const noexcept {
-        return !this->empty();
-    }
-
-    inline void clear() {
-        this->c.clear();
-    }
-
-    inline S& Container() {
-        return this->c;
-    }
-
-    inline const S& Container() const {
-        return this->c;
-    }
-};

package/inc/util/generic/refcount.h

@@ -1,162 +0,0 @@
-#pragma once
-
-#include <util/system/guard.h>
-#include <util/system/atomic.h>
-#include <util/system/defaults.h>
-#include <util/system/yassert.h>
-
-template <class TCounterCheckPolicy>
-class TSimpleCounterTemplate: public TCounterCheckPolicy {
-    using TCounterCheckPolicy::Check;
-
-public:
-    inline TSimpleCounterTemplate(long initial = 0) noexcept
-        : Counter_(initial)
-    {
-    }
-
-    inline ~TSimpleCounterTemplate() {
-        Check();
-    }
-
-    inline TAtomicBase Add(TAtomicBase d) noexcept {
-        Check();
-        return Counter_ += d;
-    }
-
-    inline TAtomicBase Inc() noexcept {
-        return Add(1);
-    }
-
-    inline TAtomicBase Sub(TAtomicBase d) noexcept {
-        Check();
-        return Counter_ -= d;
-    }
-
-    inline TAtomicBase Dec() noexcept {
-        return Sub(1);
-    }
-
-    inline bool TryWeakInc() noexcept {
-        if (!Counter_) {
-            return false;
-        }
-
-        Inc();
-        Y_ASSERT(Counter_ != 0);
-
-        return true;
-    }
-
-    inline TAtomicBase Val() const noexcept {
-        return Counter_;
-    }
-
-private:
-    TAtomicBase Counter_;
-};
-
-class TNoCheckPolicy {
-protected:
-    inline void Check() const {
-    }
-};
-
-#if defined(SIMPLE_COUNTER_THREAD_CHECK)
-
-#include <util/system/thread.i>
-
-class TCheckPolicy {
-public:
-    inline TCheckPolicy() {
-        ThreadId = SystemCurrentThreadId();
-    }
-
-protected:
-    inline void Check() const {
-        Y_VERIFY(ThreadId == SystemCurrentThreadId(), "incorrect usage of TSimpleCounter");
-    }
-
-private:
-    size_t ThreadId;
-};
-#else
-using TCheckPolicy = TNoCheckPolicy;
-#endif
-
-// Use this one if access from multiple threads to your pointer is an error and you want to enforce thread checks
-using TSimpleCounter = TSimpleCounterTemplate<TCheckPolicy>;
-// Use this one if you do want to share the pointer between threads, omit thread checks and do the synchronization yourself
-using TExplicitSimpleCounter = TSimpleCounterTemplate<TNoCheckPolicy>;
-
-template <class TCounterCheckPolicy>
-struct TCommonLockOps<TSimpleCounterTemplate<TCounterCheckPolicy>> {
-    static inline void Acquire(TSimpleCounterTemplate<TCounterCheckPolicy>* t) noexcept {
-        t->Inc();
-    }
-
-    static inline void Release(TSimpleCounterTemplate<TCounterCheckPolicy>* t) noexcept {
-        t->Dec();
-    }
-};
-
-class TAtomicCounter {
-public:
-    inline TAtomicCounter(long initial = 0) noexcept
-        : Counter_(initial)
-    {
-    }
-
-    inline ~TAtomicCounter() = default;
-
-    inline TAtomicBase Add(TAtomicBase d) noexcept {
-        return AtomicAdd(Counter_, d);
-    }
-
-    inline TAtomicBase Inc() noexcept {
-        return Add(1);
-    }
-
-    inline TAtomicBase Sub(TAtomicBase d) noexcept {
-        return AtomicSub(Counter_, d);
-    }
-
-    inline TAtomicBase Dec() noexcept {
-        return Sub(1);
-    }
-
-    inline TAtomicBase Val() const noexcept {
-        return AtomicGet(Counter_);
-    }
-
-    inline bool TryWeakInc() noexcept {
-        while (true) {
-            intptr_t curValue = Counter_;
-
-            if (!curValue) {
-                return false;
-            }
-
-            intptr_t newValue = curValue + 1;
-            Y_ASSERT(newValue != 0);
-
-            if (AtomicCas(&Counter_, newValue, curValue)) {
-                return true;
-            }
-        }
-    }
-
-private:
-    TAtomic Counter_;
-};
-
-template <>
-struct TCommonLockOps<TAtomicCounter> {
-    static inline void Acquire(TAtomicCounter* t) noexcept {
-        t->Inc();
-    }
-
-    static inline void Release(TAtomicCounter* t) noexcept {
-        t->Dec();
-    }
-};

package/inc/util/generic/reserve.h

@@ -1,11 +0,0 @@
-#pragma once
-
-namespace NDetail {
-    struct TReserveTag {
-        size_t Capacity;
-    };
-}
-
-inline ::NDetail::TReserveTag Reserve(size_t capacity) {
-    return ::NDetail::TReserveTag{capacity};
-}

package/inc/util/generic/scope.h

@@ -1,65 +0,0 @@
-#pragma once
-
-#include <util/system/compiler.h>
-#include <util/system/defaults.h>
-
-#include <utility>
-
-namespace NPrivate {
-    template <typename F>
-    class TScopeGuard {
-    public:
-        TScopeGuard(const F& function)
-            : Function_{function}
-        {
-        }
-
-        TScopeGuard(F&& function)
-            : Function_{std::move(function)}
-        {
-        }
-
-        TScopeGuard(TScopeGuard&&) = default;
-        TScopeGuard(const TScopeGuard&) = default;
-
-        ~TScopeGuard() {
-            Function_();
-        }
-
-    private:
-        F Function_;
-    };
-
-    struct TMakeGuardHelper {
-        template <class F>
-        TScopeGuard<F> operator | (F&& function) const {
-            return std::forward<F>(function);
-        }
-    };
-}
-
-// \brief `Y_SCOPE_EXIT(captures) { body };`
-//
-// General implementaion of RAII idiom (resource acquisition is initialization). Executes
-// function upon return from the current scope.
-//
-// @note expects `body` to provide no-throw guarantee, otherwise whenever an exception
-// is thrown and leaves the outermost block of `body`, the function `std::terminate` is called.
-// @see http://drdobbs.com/184403758 for detailed motivation.
-#define Y_SCOPE_EXIT(...) const auto Y_GENERATE_UNIQUE_ID(scopeGuard) Y_DECLARE_UNUSED = ::NPrivate::TMakeGuardHelper{} | [__VA_ARGS__]() mutable -> void
-
-// \brief `Y_DEFER { body };`
-//
-// Same as `Y_SCOPE_EXIT` but doesn't require user to provide capture-list explicitly (it
-// implicitly uses `[&]` capture). Have same requirements for `body`.
-//
-// Inspired by `defer` statement in languages like Swift and Go.
-//
-// \code
-// auto item = s.pop();
-// bool ok = false;
-// Y_DEFER { if (!ok) { s.push(std::move(item)); } };
-// ... try handle `item` ...
-// ok = true;
-// \endcode
-#define Y_DEFER Y_SCOPE_EXIT(&)

package/inc/util/generic/serialized_enum.h

@@ -1,406 +0,0 @@
-#pragma once
-
-#include <util/generic/fwd.h>
-#include <util/generic/vector.h>
-#include <util/generic/map.h>
-
-#include <cstddef>
-#include <type_traits>
-
-/*
-
-A file with declarations of enumeration-related functions.
-It doesn't contains definitions. To generate them you have to add
-
-    GENERATE_ENUM_SERIALIZATION_WITH_HEADER(your_header_with_your_enum.h)
-or
-    GENERATE_ENUM_SERIALIZATION(your_header_with_your_enum.h)
-
-in your ya.make
-
-@see https://st.yandex-team.ru/IGNIETFERRO-333
-@see https://wiki.yandex-team.ru/PoiskovajaPlatforma/Build/WritingCmakefiles/#generate-enum-with-header
-
-*/
-
-/**
- * Returns number of distinct items in enum or enum class
- *
- * @tparam EnumT     enum type
- */
-template <typename EnumT>
-Y_CONST_FUNCTION
-constexpr size_t GetEnumItemsCount();
-
-namespace NEnumSerializationRuntime {
-    namespace NDetail {
-        template <typename EEnum>
-        struct TSelectEnumRepresentationType;
-
-        template <typename TEnumType, typename TRepresentationType, class TStorage = TVector<TRepresentationType>>
-        class TMappedArrayView;
-
-        template <typename TEnumType, typename TRepresentationType, typename TValueType, class TStorage = TMap<TRepresentationType, TValueType>>
-        class TMappedDictView;
-    }
-
-    /// Class with behaviour similar to TMap<EnumT, TValueType>
-    template <typename EnumT, typename TValueType>
-    using TMappedDictView = NDetail::TMappedDictView<EnumT, typename NDetail::TSelectEnumRepresentationType<EnumT>::TType, TValueType>;
-
-    /// Class with behaviour similar to TVector<EnumT>
-    template <typename EnumT>
-    using TMappedArrayView = NDetail::TMappedArrayView<EnumT, typename NDetail::TSelectEnumRepresentationType<EnumT>::TType>;
-
-    /**
-     * Returns names for items in enum or enum class
-     *
-     * @tparam EnumT     enum type
-     */
-    template <typename EnumT>
-    TMappedDictView<EnumT, TString> GetEnumNamesImpl();
-    /**
-     * Returns unique items in enum or enum class
-     *
-     * @tparam EnumT     enum type
-     */
-    template <typename EnumT>
-    ::NEnumSerializationRuntime::TMappedArrayView<EnumT> GetEnumAllValuesImpl();
-
-    /**
-     * Returns human-readable comma-separated list of names in enum or enum class
-     *
-     * @tparam EnumT     enum type
-     */
-    template <typename EnumT>
-    const TString& GetEnumAllNamesImpl();
-
-    /**
-     * Returns C++ identifiers for items in enum or enum class
-     *
-     * @tparam EnumT     enum type
-     */
-    template <typename EnumT>
-    const TVector<TString>& GetEnumAllCppNamesImpl();
-}
-
-/**
- * Returns names for items in enum or enum class
- *
- * @tparam EnumT     enum type
- */
-template <typename EnumT>
-Y_CONST_FUNCTION
-::NEnumSerializationRuntime::TMappedDictView<EnumT, TString> GetEnumNames() {
-    return ::NEnumSerializationRuntime::GetEnumNamesImpl<EnumT>();
-}
-
-/**
- * Returns unique items in enum or enum class
- *
- * @tparam EnumT     enum type
- */
-template <typename EnumT>
-Y_CONST_FUNCTION
-::NEnumSerializationRuntime::TMappedArrayView<EnumT> GetEnumAllValues() {
-    return ::NEnumSerializationRuntime::GetEnumAllValuesImpl<EnumT>();
-}
-
-/**
- * Returns human-readable comma-separated list of names in enum or enum class
- *
- * @tparam EnumT     enum type
- */
-template <typename EnumT>
-Y_CONST_FUNCTION
-const TString& GetEnumAllNames() {
-    return ::NEnumSerializationRuntime::GetEnumAllNamesImpl<EnumT>();
-}
-
-/**
- * Returns C++ identifiers for items in enum or enum class
- *
- * @tparam EnumT     enum type
- */
-template <typename EnumT>
-Y_CONST_FUNCTION
-const TVector<TString>& GetEnumAllCppNames() {
-    return ::NEnumSerializationRuntime::GetEnumAllCppNamesImpl<EnumT>();
-}
-
-namespace NEnumSerializationRuntime {
-    namespace NDetail {
-        /// Checks that the `From` type can be promoted up to the `To` type without losses
-        template <typename From, typename To>
-        struct TIsPromotable: public std::is_same<std::common_type_t<From, To>, To> {
-            static_assert(std::is_integral<From>::value, "`From` type has to be an integer");
-            static_assert(std::is_integral<To>::value, "`To` type has to be an integer");
-        };
-
-        /// Selects enum representation type. Works like std::underlying_type_t<>, but promotes small types up to `int`
-        template <typename EEnum>
-        struct TSelectEnumRepresentationType {
-            using TUnderlyingType = std::underlying_type_t<EEnum>;
-            using TIsSigned = std::is_signed<TUnderlyingType>;
-            using TRepresentationType = std::conditional_t<
-                TIsSigned::value,
-                std::conditional_t<
-                    TIsPromotable<TUnderlyingType, int>::value,
-                    int,
-                    long long>,
-                std::conditional_t<
-                    TIsPromotable<TUnderlyingType, unsigned>::value,
-                    unsigned,
-                    unsigned long long>>;
-            using TType = TRepresentationType;
-            static_assert(sizeof(TUnderlyingType) <= sizeof(TType), "size of `TType` is not smaller than the size of `TUnderlyingType`");
-        };
-
-        template <typename TEnumType, typename TRepresentationType>
-        class TMappedViewBase {
-            static_assert(sizeof(std::underlying_type_t<TEnumType>) <= sizeof(TRepresentationType), "Internal type is probably too small to represent all possible values");
-
-        public:
-            static constexpr TEnumType CastFromRepresentationType(const TRepresentationType key) noexcept {
-                return static_cast<TEnumType>(key);
-            }
-
-            static constexpr TRepresentationType CastToRepresentationType(const TEnumType key) noexcept {
-                return static_cast<TRepresentationType>(key);
-            }
-        };
-
-        /// Wrapper class with behaviour similar to TVector<EnumT>
-        ///
-        /// @tparam TEnumType            enum type at the external interface
-        /// @tparam TRepresentationType  designated underlying type of enum
-        /// @tparam TStorage             internal container type
-        template <typename TEnumType, typename TRepresentationType, class TStorage>
-        class TMappedArrayView: public TMappedViewBase<TEnumType, TRepresentationType> {
-        public:
-            using value_type = TEnumType;
-
-        public:
-            TMappedArrayView(const TStorage& a) noexcept
-                : Ref(a)
-            {
-            }
-
-            class TIterator {
-            public:
-                using TSlaveIteratorType = typename TStorage::const_iterator;
-
-                using difference_type = std::ptrdiff_t;
-                using value_type = TEnumType;
-                using pointer = const TEnumType*;
-                using reference = const TEnumType&;
-                using iterator_category = std::bidirectional_iterator_tag;
-
-            public:
-                TIterator(TSlaveIteratorType it)
-                    : Slave(std::move(it))
-                {
-                }
-
-                bool operator==(const TIterator& it) const {
-                    return Slave == it.Slave;
-                }
-
-                bool operator!=(const TIterator& it) const {
-                    return !(*this == it);
-                }
-
-                TEnumType operator*() const {
-                    return TMappedArrayView::CastFromRepresentationType(*Slave);
-                }
-
-                TIterator& operator++() {
-                    ++Slave;
-                    return *this;
-                }
-
-                TIterator& operator--() {
-                    --Slave;
-                    return *this;
-                }
-
-                TIterator operator++(int) {
-                    auto temp = Slave;
-                    ++Slave;
-                    return temp;
-                }
-
-                TIterator operator--(int) {
-                    auto temp = Slave;
-                    --Slave;
-                    return temp;
-                }
-
-            private:
-                TSlaveIteratorType Slave;
-            };
-
-            TIterator begin() const {
-                return Ref.begin();
-            }
-
-            TIterator end() const {
-                return Ref.end();
-            }
-
-            size_t size() const {
-                return Ref.size();
-            }
-
-            Y_PURE_FUNCTION
-            bool empty() const {
-                return Ref.empty();
-            }
-
-            TEnumType at(size_t index) const {
-                return this->CastFromRepresentationType(Ref.at(index));
-            }
-
-            TEnumType operator[](size_t index) const {
-                return this->CastFromRepresentationType(Ref[index]);
-            }
-
-            // Allocate container and copy view's content into it
-            template <template <class...> class TContainer = TVector>
-            TContainer<TEnumType> Materialize() const {
-                return {begin(), end()};
-            }
-
-        private:
-            const TStorage& Ref;
-        };
-
-        /// Wrapper class with behaviour similar to TMap<EnumT, TValueType>
-        ///
-        /// @tparam TEnumType            enum type at the external interface
-        /// @tparam TRepresentationType  designated underlying type of enum
-        /// @tparam TValueType           mapped value
-        /// @tparam TStorage             internal container type
-        template <typename TEnumType, typename TRepresentationType, typename TValueType, class TStorage>
-        class TMappedDictView: public TMappedViewBase<TEnumType, TRepresentationType> {
-        public:
-            using TMappedItemType = std::pair<const TEnumType, const TValueType&>;
-
-            class TDereferenceResultHolder {
-            public:
-                TDereferenceResultHolder(const TRepresentationType enumValue, const TValueType& payload) noexcept
-                    : Data(TMappedDictView::CastFromRepresentationType(enumValue), payload)
-                {
-                }
-
-                const TMappedItemType* operator->() const noexcept {
-                    return &Data;
-                }
-
-            private:
-                TMappedItemType Data;
-            };
-
-            TMappedDictView(const TStorage& m) noexcept
-                : Ref(m)
-            {
-            }
-
-            class TIterator {
-            public:
-                using TSlaveIteratorType = typename TStorage::const_iterator;
-
-                using difference_type = std::ptrdiff_t;
-                using value_type = TMappedItemType;
-                using pointer = const TMappedItemType*;
-                using reference = const TMappedItemType&;
-                using iterator_category = std::bidirectional_iterator_tag;
-
-            public:
-                TIterator(TSlaveIteratorType it)
-                    : Slave(std::move(it))
-                {
-                }
-
-                bool operator==(const TIterator& it) const {
-                    return Slave == it.Slave;
-                }
-
-                bool operator!=(const TIterator& it) const {
-                    return !(*this == it);
-                }
-
-                TDereferenceResultHolder operator->() const {
-                    return {Slave->first, Slave->second};
-                }
-
-                TMappedItemType operator*() const {
-                    return {TMappedDictView::CastFromRepresentationType(Slave->first), Slave->second};
-                }
-
-                TIterator& operator++() {
-                    ++Slave;
-                    return *this;
-                }
-
-                TIterator& operator--() {
-                    --Slave;
-                    return *this;
-                }
-
-                TIterator operator++(int) {
-                    auto temp = Slave;
-                    ++Slave;
-                    return temp;
-                }
-
-                TIterator operator--(int) {
-                    auto temp = Slave;
-                    --Slave;
-                    return temp;
-                }
-
-            private:
-                TSlaveIteratorType Slave;
-            };
-
-            TIterator begin() const {
-                return Ref.begin();
-            }
-
-            TIterator end() const {
-                return Ref.end();
-            }
-
-            size_t size() const {
-                return Ref.size();
-            }
-
-            Y_PURE_FUNCTION
-            bool empty() const {
-                return Ref.empty();
-            }
-
-            bool contains(const TEnumType key) const {
-                return Ref.contains(this->CastToRepresentationType(key));
-            }
-
-            TIterator find(const TEnumType key) const {
-                return Ref.find(this->CastToRepresentationType(key));
-            }
-
-            const TValueType& at(const TEnumType key) const {
-                return Ref.at(this->CastToRepresentationType(key));
-            }
-
-            // Allocate container and copy view's content into it
-            template <template <class...> class TContainer = TMap>
-            TContainer<TEnumType, TValueType> Materialize() const {
-                return {begin(), end()};
-            }
-
-        private:
-            const TStorage& Ref;
-        };
-    }
-}