catboost 1.25.1 → 1.27.0

package/inc/util/generic/maybe_traits.h

@@ -1,164 +0,0 @@
-#pragma once
-
-#include <type_traits>
-#include <initializer_list>
-
-namespace NMaybe {
-    struct TInPlace {};
-
-    template <class T, bool = std::is_trivially_destructible<T>::value>
-    struct TStorageBase {
-        constexpr TStorageBase() noexcept
-            : NullState_('\0') {}
-
-        template <class... Args>
-        constexpr TStorageBase(TInPlace, Args&&... args)
-            : Data_(std::forward<Args>(args)...)
-            , Defined_(true) {}
-
-        ~TStorageBase() = default;
-
-        union {
-            char NullState_;
-            T Data_;
-        };
-        bool Defined_ = false;
-    };
-
-    template <class T>
-    struct TStorageBase<T, false> {
-        constexpr TStorageBase() noexcept
-            : NullState_('\0') {}
-
-        template <class... Args>
-        constexpr TStorageBase(TInPlace, Args&&... args)
-            : Data_(std::forward<Args>(args)...)
-            , Defined_(true) {}
-
-        ~TStorageBase() {
-            if (this->Defined_) {
-                this->Data_.~T();
-            }
-        }
-
-        union {
-            char NullState_;
-            T Data_;
-        };
-        bool Defined_ = false;
-    };
-
-    // -------------------- COPY CONSTRUCT --------------------
-
-    template <class T, bool = std::is_trivially_copy_constructible<T>::value>
-    struct TCopyBase : TStorageBase<T> {
-        using TStorageBase<T>::TStorageBase;
-    };
-
-    template <class T>
-    struct TCopyBase<T, false> : TStorageBase<T>  {
-        using TStorageBase<T>::TStorageBase;
-
-        constexpr TCopyBase() = default;
-        constexpr TCopyBase(const TCopyBase& rhs) {
-            if (rhs.Defined_) {
-                new (std::addressof(this->Data_)) T(rhs.Data_);
-                this->Defined_ = true;
-            }
-        }
-        constexpr TCopyBase(TCopyBase&&) = default;
-        TCopyBase& operator=(const TCopyBase&) = default;
-        TCopyBase& operator=(TCopyBase&&) = default;
-    };
-
-    // -------------------- MOVE CONSTRUCT --------------------
-
-    template <class T, bool = std::is_trivially_move_constructible<T>::value>
-    struct TMoveBase : TCopyBase<T> {
-        using TCopyBase<T>::TCopyBase;
-    };
-
-    template <class T>
-    struct TMoveBase<T, false> : TCopyBase<T> {
-        using TCopyBase<T>::TCopyBase;
-
-        constexpr TMoveBase() noexcept = default;
-        constexpr TMoveBase(const TMoveBase&) = default;
-        constexpr TMoveBase(TMoveBase&& rhs) noexcept(std::is_nothrow_move_constructible<T>::value) {
-            if (rhs.Defined_) {
-                new (std::addressof(this->Data_)) T(std::move(rhs.Data_));
-                this->Defined_ = true;
-            }
-        }
-        TMoveBase& operator=(const TMoveBase&) = default;
-        TMoveBase& operator=(TMoveBase&&) = default;
-    };
-
-    // -------------------- COPY ASSIGN --------------------
-
-    template <class T, bool = std::is_trivially_copy_assignable<T>::value>
-    struct TCopyAssignBase : TMoveBase<T> {
-        using TMoveBase<T>::TMoveBase;
-    };
-
-    template <class T>
-    struct TCopyAssignBase<T, false> : TMoveBase<T> {
-        using TMoveBase<T>::TMoveBase;
-
-        constexpr TCopyAssignBase() noexcept = default;
-        constexpr TCopyAssignBase(const TCopyAssignBase&) = default;
-        constexpr TCopyAssignBase(TCopyAssignBase&&) = default;
-        TCopyAssignBase& operator=(const TCopyAssignBase& rhs) {
-            if (this->Defined_) {
-                if (rhs.Defined_) {
-                    this->Data_ = rhs.Data_;
-                } else {
-                    this->Data_.~T();
-                    this->Defined_ = false;
-                }
-            } else if (rhs.Defined_) {
-                new (std::addressof(this->Data_)) T(rhs.Data_);
-                this->Defined_ = true;
-            }
-            return *this;
-        }
-        TCopyAssignBase& operator=(TCopyAssignBase&&) = default;
-    };
-
-    // -------------------- MOVE ASSIGN --------------------
-
-    template <class T, bool = std::is_trivially_copy_assignable<T>::value>
-    struct TMoveAssignBase : TCopyAssignBase<T> {
-        using TCopyAssignBase<T>::TCopyAssignBase;
-    };
-
-    template <class T>
-    struct TMoveAssignBase<T, false> : TCopyAssignBase<T> {
-        using TCopyAssignBase<T>::TCopyAssignBase;
-
-        constexpr TMoveAssignBase() noexcept = default;
-        constexpr TMoveAssignBase(const TMoveAssignBase&) = default;
-        constexpr TMoveAssignBase(TMoveAssignBase&&) = default;
-        TMoveAssignBase& operator=(const TMoveAssignBase&) = default;
-        TMoveAssignBase& operator=(TMoveAssignBase&& rhs) noexcept(
-            std::is_nothrow_move_assignable<T>::value &&
-            std::is_nothrow_move_constructible<T>::value)
-        {
-            if (this->Defined_) {
-                if (rhs.Defined_) {
-                    this->Data_ = std::move(rhs.Data_);
-                } else {
-                    this->Data_.~T();
-                    this->Defined_ = false;
-                }
-            } else if (rhs.Defined_) {
-                new (std::addressof(this->Data_)) T(std::move(rhs.Data_));
-                this->Defined_ = true;
-            }
-            return *this;
-        }
-    };
-}
-
-template <class T>
-using TMaybeBase = NMaybe::TMoveAssignBase<T>;

package/inc/util/generic/mem_copy.h

@@ -1,55 +0,0 @@
-#pragma once
-
-#include "typetraits.h"
-
-#include <util/system/types.h>
-
-#include <cstring>
-
-template <class T>
-using TIfPOD = std::enable_if_t<TTypeTraits<T>::IsPod, T*>;
-
-template <class T>
-using TIfNotPOD = std::enable_if_t<!TTypeTraits<T>::IsPod, T*>;
-
-template <class T>
-static inline TIfPOD<T> MemCopy(T* to, const T* from, size_t n) noexcept {
-    if (n) {
-        memcpy(to, from, n * sizeof(T));
-    }
-
-    return to;
-}
-
-template <class T>
-static inline TIfNotPOD<T> MemCopy(T* to, const T* from, size_t n) {
-    for (size_t i = 0; i < n; ++i) {
-        to[i] = from[i];
-    }
-
-    return to;
-}
-
-template <class T>
-static inline TIfPOD<T> MemMove(T* to, const T* from, size_t n) noexcept {
-    if (n) {
-        memmove(to, from, n * sizeof(T));
-    }
-
-    return to;
-}
-
-template <class T>
-static inline TIfNotPOD<T> MemMove(T* to, const T* from, size_t n) {
-    if (to <= from || to >= from + n) {
-        return MemCopy(to, from, n);
-    }
-
-    //copy backwards
-    while (n) {
-        to[n - 1] = from[n - 1];
-        --n;
-    }
-
-    return to;
-}

package/inc/util/generic/noncopyable.h

@@ -1,38 +0,0 @@
-#pragma once
-
-/**
- * @class TNonCopyable
- *
- * Inherit your class from `TNonCopyable` if you want to make it noncopyable.
- *
- * Example usage:
- * @code
- * class Foo: private TNonCopyable {
- *     // ...
- * };
- * @endcode
- */
-
-namespace NNonCopyable { // protection from unintended ADL
-    struct TNonCopyable {
-        TNonCopyable(const TNonCopyable&) = delete;
-        TNonCopyable& operator=(const TNonCopyable&) = delete;
-
-        TNonCopyable() = default;
-        ~TNonCopyable() = default;
-    };
-
-    struct TMoveOnly {
-        TMoveOnly(TMoveOnly&&) noexcept = default;
-        TMoveOnly& operator=(TMoveOnly&&) noexcept = default;
-
-        TMoveOnly(const TMoveOnly&) = delete;
-        TMoveOnly& operator=(const TMoveOnly&) = delete;
-
-        TMoveOnly() = default;
-        ~TMoveOnly() = default;
-    };
-}
-
-using TNonCopyable = NNonCopyable::TNonCopyable;
-using TMoveOnly = NNonCopyable::TMoveOnly;

package/inc/util/generic/object_counter.h

@@ -1,53 +0,0 @@
-#pragma once
-
-#include <util/system/atomic.h>
-
-/**
- * Simple thread-safe per-class counter that can be used to make sure you don't
- * have any leaks in your code, or for statistical purposes.
- *
- * Example usage:
- * \code
- * class TMyClass: public TObjectCounter<TMyClass> {
- *     // ...
- * };
- *
- * // In your code:
- * Cerr << "TMyClass instances in use: " << TMyClass::ObjectCount() << Endl;
- * \endcode
- */
-template <class T>
-class TObjectCounter {
-public:
-    inline TObjectCounter() noexcept {
-        AtomicIncrement(Count_);
-    }
-
-    inline TObjectCounter(const TObjectCounter& /*item*/) noexcept {
-        AtomicIncrement(Count_);
-    }
-
-    inline ~TObjectCounter() {
-        AtomicDecrement(Count_);
-    }
-
-    static inline long ObjectCount() noexcept {
-        return AtomicGet(Count_);
-    }
-
-    /**
-     * Resets object count. Mainly for tests, as you don't want to do this in
-     * your code and then end up with negative counts.
-     *
-     * \returns                         Current object count.
-     */
-    static inline long ResetObjectCount() noexcept {
-        return AtomicSwap(&Count_, 0);
-    }
-
-private:
-    static TAtomic Count_;
-};
-
-template <class T>
-TAtomic TObjectCounter<T>::Count_ = 0;