catboost 1.25.1 → 1.26.0

package/inc/util/generic/set.h

@@ -1,42 +0,0 @@
-#pragma once
-
-#include "fwd.h"
-
-#include <util/str_stl.h>
-#include <util/memory/alloc.h>
-
-#include <initializer_list>
-#include <memory>
-#include <set>
-
-template <class K, class L, class A>
-class TSet: public std::set<K, L, TReboundAllocator<A, K>> {
-public:
-    using TBase = std::set<K, L, TReboundAllocator<A, K>>;
-    using TBase::TBase;
-
-    inline explicit operator bool() const noexcept {
-        return !this->empty();
-    }
-
-    template <class TheKey>
-    inline bool contains(const TheKey& key) const {
-        return this->find(key) != this->end();
-    }
-};
-
-template <class K, class L, class A>
-class TMultiSet: public std::multiset<K, L, TReboundAllocator<A, K>> {
-public:
-    using TBase = std::multiset<K, L, TReboundAllocator<A, K>>;
-    using TBase::TBase;
-
-    inline explicit operator bool() const noexcept {
-        return !this->empty();
-    }
-
-    template <class TheKey>
-    inline bool contains(const TheKey& key) const {
-        return this->find(key) != this->end();
-    }
-};

package/inc/util/generic/singleton.h

@@ -1,136 +0,0 @@
-#pragma once
-
-#include <util/system/atexit.h>
-#include <util/system/atomic.h>
-
-#include <new>
-#include <utility>
-
-template <class T>
-struct TSingletonTraits {
-    static constexpr size_t Priority = 65536;
-};
-
-namespace NPrivate {
-    void FillWithTrash(void* ptr, size_t len);
-
-    void LockRecursive(TAtomic& lock) noexcept;
-    void UnlockRecursive(TAtomic& lock) noexcept;
-
-    template <class T>
-    void Destroyer(void* ptr) {
-        ((T*)ptr)->~T();
-        FillWithTrash(ptr, sizeof(T));
-    }
-
-    template <class T, size_t P, class... TArgs>
-    Y_NO_INLINE T* SingletonBase(T*& ptr, TArgs&&... args) {
-        alignas(T) static char buf[sizeof(T)];
-        static TAtomic lock;
-
-        LockRecursive(lock);
-
-        auto ret = AtomicGet(ptr);
-
-        try {
-            if (!ret) {
-                ret = ::new (buf) T(std::forward<TArgs>(args)...);
-
-                try {
-                    AtExit(Destroyer<T>, ret, P);
-                } catch (...) {
-                    Destroyer<T>(ret);
-
-                    throw;
-                }
-
-                AtomicSet(ptr, ret);
-            }
-        } catch (...) {
-            UnlockRecursive(lock);
-
-            throw;
-        }
-
-        UnlockRecursive(lock);
-
-        return ret;
-    }
-
-    template <class T, size_t P, class... TArgs>
-    T* SingletonInt(TArgs&&... args) {
-        static_assert(sizeof(T) < 32000, "use HugeSingleton instead");
-
-        static T* ptr;
-        auto ret = AtomicGet(ptr);
-
-        if (Y_UNLIKELY(!ret)) {
-            ret = SingletonBase<T, P>(ptr, std::forward<TArgs>(args)...);
-        }
-
-        return ret;
-    }
-
-    template <class T>
-    class TDefault {
-    public:
-        template <class... TArgs>
-        inline TDefault(TArgs&&... args)
-            : T_(std::forward<TArgs>(args)...)
-        {
-        }
-
-        inline const T* Get() const noexcept {
-            return &T_;
-        }
-
-    private:
-        T T_;
-    };
-
-    template <class T>
-    struct THeapStore {
-        template <class... TArgs>
-        inline THeapStore(TArgs&&... args)
-            : D(new T(std::forward<TArgs>(args)...))
-        {
-        }
-
-        inline ~THeapStore() {
-            delete D;
-        }
-
-        T* D;
-    };
-}
-
-#define Y_DECLARE_SINGLETON_FRIEND()                \
-    template <class T, size_t P, class... TArgs>    \
-    friend T* ::NPrivate::SingletonInt(TArgs&&...); \
-    template <class T, size_t P, class... TArgs>    \
-    friend T* ::NPrivate::SingletonBase(T*&, TArgs&&...);
-
-template <class T, class... TArgs>
-T* Singleton(TArgs&&... args) {
-    return ::NPrivate::SingletonInt<T, TSingletonTraits<T>::Priority>(std::forward<TArgs>(args)...);
-}
-
-template <class T, class... TArgs>
-T* HugeSingleton(TArgs&&... args) {
-    return Singleton< ::NPrivate::THeapStore<T>>(std::forward<TArgs>(args)...)->D;
-}
-
-template <class T, size_t P, class... TArgs>
-T* SingletonWithPriority(TArgs&&... args) {
-    return ::NPrivate::SingletonInt<T, P>(std::forward<TArgs>(args)...);
-}
-
-template <class T, size_t P, class... TArgs>
-T* HugeSingletonWithPriority(TArgs&&... args) {
-    return SingletonWithPriority< ::NPrivate::THeapStore<T>, P>(std::forward<TArgs>(args)...)->D;
-}
-
-template <class T>
-const T& Default() {
-    return *(::NPrivate::SingletonInt<typename ::NPrivate::TDefault<T>, TSingletonTraits<T>::Priority>()->Get());
-}

package/inc/util/generic/size_literals.h

@@ -1,65 +0,0 @@
-#pragma once
-
-#include "yexception.h"
-#include <util/system/types.h>
-#include <limits>
-
-// Unsigned literals
-
-constexpr ui64 operator"" _KB(unsigned long long value) noexcept {
-    return value * 1024;
-}
-
-constexpr ui64 operator"" _MB(unsigned long long value) noexcept {
-    return value * 1024_KB;
-}
-
-constexpr ui64 operator"" _GB(unsigned long long value) noexcept {
-    return value * 1024_MB;
-}
-
-constexpr ui64 operator"" _TB(unsigned long long value) noexcept {
-    return value * 1024_GB;
-}
-
-constexpr ui64 operator"" _PB(unsigned long long value) noexcept {
-    return value * 1024_TB;
-}
-
-constexpr ui64 operator"" _EB(unsigned long long value) noexcept {
-    return value * 1024_PB;
-}
-
-// Signed literals
-
-namespace NPrivate {
-    constexpr i64 SignedCast(ui64 value) {
-        return value <= static_cast<ui64>(std::numeric_limits<i64>::max())
-                   ? static_cast<i64>(value)
-                   : ythrow yexception() << "The resulting value " << value << " does not fit into the i64 type";
-    };
-}
-
-constexpr i64 operator"" _KBs(const unsigned long long value) noexcept {
-    return ::NPrivate::SignedCast(value * 1024);
-}
-
-constexpr i64 operator"" _MBs(unsigned long long value) noexcept {
-    return ::NPrivate::SignedCast(value * 1024_KB);
-}
-
-constexpr i64 operator"" _GBs(unsigned long long value) noexcept {
-    return ::NPrivate::SignedCast(value * 1024_MB);
-}
-
-constexpr i64 operator"" _TBs(unsigned long long value) noexcept {
-    return ::NPrivate::SignedCast(value * 1024_GB);
-}
-
-constexpr i64 operator"" _PBs(unsigned long long value) noexcept {
-    return ::NPrivate::SignedCast(value * 1024_TB);
-}
-
-constexpr i64 operator"" _EBs(unsigned long long value) noexcept {
-    return ::NPrivate::SignedCast(value * 1024_PB);
-}

package/inc/util/generic/stack.h

@@ -1,18 +0,0 @@
-#pragma once
-
-#include "fwd.h"
-#include "deque.h"
-
-#include <stack>
-
-template <class T, class S>
-class TStack: public std::stack<T, S> {
-    using TBase = std::stack<T, S>;
-
-public:
-    using TBase::TBase;
-
-    inline explicit operator bool() const noexcept {
-        return !this->empty();
-    }
-};

package/inc/util/generic/store_policy.h

@@ -1,120 +0,0 @@
-#pragma once
-
-#include <utility>
-#include "ptr.h"
-
-template <class TBase, class TCounter>
-struct TWithRefCount: public TBase, public TRefCounted<TWithRefCount<TBase, TCounter>, TCounter> {
-    template <typename... Args>
-    inline TWithRefCount(Args&&... args)
-        : TBase(std::forward<Args>(args)...)
-    {
-    }
-};
-
-template <class T>
-struct TPtrPolicy {
-    inline TPtrPolicy(T* t)
-        : T_(t)
-    {
-    }
-
-    inline T* Ptr() noexcept {
-        return T_;
-    }
-
-    inline const T* Ptr() const noexcept {
-        return T_;
-    }
-
-    T* T_;
-};
-
-template <class T>
-struct TEmbedPolicy {
-    template <typename... Args>
-    inline TEmbedPolicy(Args&&... args)
-        : T_(std::forward<Args>(args)...)
-    {
-    }
-
-    inline T* Ptr() noexcept {
-        return &T_;
-    }
-
-    inline const T* Ptr() const noexcept {
-        return &T_;
-    }
-
-    T T_;
-};
-
-template <class T, class TCounter>
-struct TRefPolicy {
-    using THelper = TWithRefCount<T, TCounter>;
-
-    template <typename... Args>
-    inline TRefPolicy(Args&&... args)
-        : T_(new THelper(std::forward<Args>(args)...))
-    {
-    }
-
-    inline T* Ptr() noexcept {
-        return T_.Get();
-    }
-
-    inline const T* Ptr() const noexcept {
-        return T_.Get();
-    }
-
-    TIntrusivePtr<THelper> T_;
-};
-
-/**
- * Storage class that can be handy for implementing proxies / adaptors that can
- * accept both lvalues and rvalues. In the latter case it's often required to
- * extend the lifetime of the passed rvalue, and the only option is to store it
- * in your proxy / adaptor.
- *
- * Example usage:
- * \code
- * template<class T>
- * struct TProxy {
- *    TAutoEmbedOrPtrPolicy<T> Value_;
- *    // Your proxy code...
- * };
- *
- * template<class T>
- * TProxy<T> MakeProxy(T&& value) {
- *     // Rvalues are automagically moved-from, and stored inside the proxy.
- *     return {std::forward<T>(value)};
- * }
- * \endcode
- *
- * Look at `Reversed` in `adaptor.h` for real example.
- */
-template <class T, bool IsReference = std::is_reference<T>::value>
-struct TAutoEmbedOrPtrPolicy: TPtrPolicy<std::remove_reference_t<T>> {
-    using TBase = TPtrPolicy<std::remove_reference_t<T>>;
-
-    TAutoEmbedOrPtrPolicy(T& reference)
-        : TBase(&reference)
-    {
-    }
-};
-
-template <class T>
-struct TAutoEmbedOrPtrPolicy<T, false> : TEmbedPolicy<T> {
-    using TBase = TEmbedPolicy<T>;
-
-    TAutoEmbedOrPtrPolicy(T&& object)
-        : TBase(std::move(object))
-    {
-    }
-};
-
-template <class T>
-using TAtomicRefPolicy = TRefPolicy<T, TAtomicCounter>;
-
-template <class T>
-using TSimpleRefPolicy = TRefPolicy<T, TSimpleCounter>;