unique_ptr.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_MEMORY_UNIQUE_PTR_HPP__
#define NEFORCE_CORE_MEMORY_UNIQUE_PTR_HPP__

 
#include "NeForce/core/functional/functor.hpp"
#include "NeForce/core/functional/invoke.hpp"
#include "NeForce/core/utility/compressed_pair.hpp"
#include "NeForce/core/utility/deleter.hpp"
NEFORCE_BEGIN_NAMESPACE__


NEFORCE_BEGIN_INNER__

template <typename T, typename Deleter>
class __unique_ptr_impl {
private:
    template <typename U, typename E, typename = void>
    struct inner_ptr {
        using type = U*;
    };
 
    template <typename U, typename E>
    struct inner_ptr<U, E, void_t<typename remove_reference_t<E>::pointer>> {
        using type = typename remove_reference<E>::type::pointer;
    };
 
public:
    using DeleterConstraint = enable_if<is_default_constructible<Deleter>::value>; 
    using pointer = typename inner_ptr<T, Deleter>::type;                          
 
private:
    compressed_pair<Deleter, pointer> ptr_pair_{default_construct_tag{}, nullptr}; 
 
    static_assert(!is_rvalue_reference<Deleter>::value,
                  "deleter type of unique_ptr must be a function object type or an lvalue reference type");
 
public:
    __unique_ptr_impl() = default;
 
    NEFORCE_CONSTEXPR20 __unique_ptr_impl(pointer ptr) :
    ptr_pair_(default_construct_tag{}, ptr) {}
 
    template <typename Del = Deleter, enable_if_t<is_constructible_v<Deleter, Del>, int> = 0>
    NEFORCE_CONSTEXPR20 __unique_ptr_impl(pointer ptr, Del&& deleter) :
    ptr_pair_(exact_arg_construct_tag{}, _NEFORCE forward<Del>(deleter), ptr) {}
 
    NEFORCE_CONSTEXPR20 __unique_ptr_impl(__unique_ptr_impl&& other) noexcept :
    ptr_pair_(_NEFORCE move(other.ptr_pair_)) {
        other.get_ptr() = nullptr;
    }
 
    NEFORCE_CONSTEXPR20 __unique_ptr_impl& operator=(__unique_ptr_impl&& other) noexcept {
        this->reset(other.release());
        return *this;
    }
 
    NEFORCE_CONSTEXPR20 pointer& get_ptr() noexcept { return ptr_pair_.value; }
 
    NEFORCE_CONSTEXPR20 pointer get_ptr() const noexcept { return ptr_pair_.value; }
 
    NEFORCE_CONSTEXPR20 Deleter& get_deleter() & noexcept { return ptr_pair_.get_base(); }
 
    NEFORCE_CONSTEXPR20 const Deleter& get_deleter() const& noexcept { return ptr_pair_.get_base(); }
 
    NEFORCE_CONSTEXPR20 Deleter&& get_deleter() && noexcept { return _NEFORCE move(ptr_pair_).get_base(); }
 
    NEFORCE_CONSTEXPR20 const Deleter&& get_deleter() const&& noexcept { return _NEFORCE move(ptr_pair_).get_base(); }
 
    NEFORCE_CONSTEXPR20 void reset(pointer ptr) noexcept {
        const pointer old = get_ptr();
        get_ptr() = ptr;
        if (old) {
            ptr_pair_.get_base()(old);
        }
    }
 
    NEFORCE_CONSTEXPR20 pointer release() noexcept {
        pointer p = get_ptr();
        get_ptr() = nullptr;
        return p;
    }
 
    NEFORCE_CONSTEXPR20 void swap(__unique_ptr_impl& other) noexcept { _NEFORCE swap(ptr_pair_, other.ptr_pair_); }
};

template <typename T, typename Deleter, bool MoveConstructible = is_move_constructible<Deleter>::value,
          bool MoveAssignable = is_move_assignable<Deleter>::value>
struct __unique_ptr_data : __unique_ptr_impl<T, Deleter> {
    using base_type = __unique_ptr_impl<T, Deleter>;
    using pointer = typename base_type::pointer;
 
    __unique_ptr_data() = default;
 
    NEFORCE_CONSTEXPR20 __unique_ptr_data(pointer ptr) :
    base_type(ptr) {}
 
    template <typename Del = Deleter, enable_if_t<is_constructible_v<Deleter, Del>, int> = 0>
    NEFORCE_CONSTEXPR20 __unique_ptr_data(pointer ptr, Del&& deleter) :
    base_type(ptr, _NEFORCE forward<Del>(deleter)) {}
 
    __unique_ptr_data(__unique_ptr_data&&) = default;
    __unique_ptr_data& operator=(__unique_ptr_data&&) = default;
};
 
// 删除器可移动构造但不可移动赋值
template <typename T, typename Deleter>
struct __unique_ptr_data<T, Deleter, true, false> : __unique_ptr_impl<T, Deleter> {
    using base_type = __unique_ptr_impl<T, Deleter>;
    using pointer = typename base_type::pointer;
 
    __unique_ptr_data() = default;
 
    NEFORCE_CONSTEXPR20 __unique_ptr_data(pointer ptr) :
    base_type(ptr) {}
 
    template <typename Del = Deleter, enable_if_t<is_constructible_v<Deleter, Del>, int> = 0>
    NEFORCE_CONSTEXPR20 __unique_ptr_data(pointer ptr, Del&& deleter) :
    base_type(ptr, _NEFORCE forward<Del>(deleter)) {}
 
    __unique_ptr_data(__unique_ptr_data&&) = default;
    __unique_ptr_data& operator=(__unique_ptr_data&&) = delete;
};
 
// 删除器可移动赋值但不可移动构造
template <typename T, typename Deleter>
struct __unique_ptr_data<T, Deleter, false, true> : __unique_ptr_impl<T, Deleter> {
    using base_type = __unique_ptr_impl<T, Deleter>;
    using pointer = typename base_type::pointer;
 
    __unique_ptr_data() = default;
 
    NEFORCE_CONSTEXPR20 __unique_ptr_data(pointer ptr) :
    base_type(ptr) {}
 
    template <typename Del = Deleter, enable_if_t<is_constructible_v<Deleter, Del>, int> = 0>
    NEFORCE_CONSTEXPR20 __unique_ptr_data(pointer ptr, Del&& deleter) :
    base_type(ptr, _NEFORCE forward<Del>(deleter)) {}
 
    __unique_ptr_data(__unique_ptr_data&&) = delete;
    __unique_ptr_data& operator=(__unique_ptr_data&&) = default;
};
 
// 删除器既不可移动构造也不可移动赋值
template <typename T, typename Deleter>
struct __unique_ptr_data<T, Deleter, false, false> : __unique_ptr_impl<T, Deleter> {
    using base_type = __unique_ptr_impl<T, Deleter>;
    using pointer = typename base_type::pointer;
 
    __unique_ptr_data() = default;
 
    NEFORCE_CONSTEXPR20 __unique_ptr_data(pointer ptr) :
    base_type(ptr) {}
 
    template <typename Del = Deleter, enable_if_t<is_constructible_v<Deleter, Del>, int> = 0>
    NEFORCE_CONSTEXPR20 __unique_ptr_data(pointer ptr, Del&& deleter) :
    base_type(ptr, _NEFORCE forward<Del>(deleter)) {}
 
    __unique_ptr_data(__unique_ptr_data&&) = delete;
    __unique_ptr_data& operator=(__unique_ptr_data&&) = delete;
};
 
NEFORCE_END_INNER__
 

template <typename T, typename Deleter = default_deleter<T>>
class unique_ptr {
private:
    template <typename U>
    using DeleterConstraint = typename inner::__unique_ptr_impl<T, U>::DeleterConstraint::type; 
 
    inner::__unique_ptr_data<T, Deleter> data_{}; 
 
public:
    using pointer = typename inner::__unique_ptr_impl<T, Deleter>::pointer; 
    using element_type = T;                                                 
    using deleter_type = Deleter;                                           
 
private:
    template <typename U, typename E>
    using safe_conversion = conjunction<is_convertible<typename unique_ptr<U, E>::pointer, pointer>,
                                        negation<is_array<U>>>; 
 
public:
    template <typename Del = Deleter, typename = DeleterConstraint<Del>>
    constexpr unique_ptr(nullptr_t = nullptr) noexcept {}

    template <typename Del = Deleter, typename = DeleterConstraint<Del>>
    NEFORCE_CONSTEXPR20 unique_ptr(pointer ptr) noexcept :
    data_(ptr) {}

    template <typename Del = Deleter, enable_if_t<is_constructible_v<Deleter, Del>, int> = 0>
    NEFORCE_CONSTEXPR20 unique_ptr(pointer ptr, Del&& deleter) noexcept :
    data_(ptr, _NEFORCE forward<Del>(deleter)) {}
 
    NEFORCE_CONSTEXPR20 unique_ptr(unique_ptr&&) noexcept = default; 

    template <typename U, typename E,
              enable_if_t<conjunction<safe_conversion<U, E>,
                                      conditional_t<is_reference<Deleter>::value, is_same<E, Deleter>,
                                                    is_convertible<E, Deleter>>>::value,
                          int> = 0>
    NEFORCE_CONSTEXPR20 unique_ptr(unique_ptr<U, E>&& other) noexcept :
    data_(other.release(), _NEFORCE forward<E>(other.get_deleter())) {}

    ~unique_ptr() noexcept {
        auto& ptr = data_.get_ptr();
        if (ptr != nullptr) {
            get_deleter()(ptr);
        }
        ptr = pointer();
    }
 
    unique_ptr& operator=(unique_ptr&&) noexcept = default; 

    template <typename U, typename E,
              enable_if_t<conjunction<safe_conversion<U, E>, is_assignable<deleter_type&, E&&>>::value, int> = 0>
    NEFORCE_CONSTEXPR20 unique_ptr& operator=(unique_ptr<U, E>&& other) noexcept {
        reset(other.release());
        get_deleter() = _NEFORCE forward<E>(other.get_deleter());
        return *this;
    }

    NEFORCE_CONSTEXPR20 unique_ptr& operator=(nullptr_t) noexcept {
        reset();
        return *this;
    }

    NEFORCE_CONSTEXPR20 add_lvalue_reference_t<element_type> operator*() const
            noexcept(noexcept(*_NEFORCE declval<pointer>())) {
        return *get();
    }

    NEFORCE_CONSTEXPR20 pointer operator->() const noexcept { return get(); }

    NEFORCE_CONSTEXPR20 pointer get() const noexcept { return data_.get_ptr(); }

    NEFORCE_CONSTEXPR20 deleter_type& get_deleter() & noexcept { return data_.get_deleter(); }
    NEFORCE_CONSTEXPR20 const deleter_type& get_deleter() const& noexcept { return data_.get_deleter(); }

    NEFORCE_CONSTEXPR20 deleter_type&& get_deleter() && noexcept { return _NEFORCE move(data_).get_deleter(); }
    NEFORCE_CONSTEXPR20 const deleter_type&& get_deleter() const&& noexcept {
        return _NEFORCE move(data_).get_deleter();
    }

    NEFORCE_CONSTEXPR20 explicit operator bool() const noexcept { return get() != pointer(); }

    NEFORCE_CONSTEXPR20 pointer release() noexcept { return data_.release(); }

    NEFORCE_CONSTEXPR20 void reset(pointer ptr = pointer()) noexcept {
        static_assert(is_invocable<deleter_type&, pointer>::value,
                      "deleter of unique_ptr must be invocable with a pointer");
        data_.reset(_NEFORCE move(ptr));
    }

    NEFORCE_CONSTEXPR20 void swap(unique_ptr& other) noexcept {
        static_assert(is_swappable<Deleter>::value, "deleter must be swappable.");
        data_.swap(other.data_);
    }
 
    unique_ptr(const unique_ptr&) = delete;            
    unique_ptr& operator=(const unique_ptr&) = delete; 
};

template <typename T, typename Deleter>
class unique_ptr<T[], Deleter> {
    template <typename U>
    using DeleterConstraint = typename inner::__unique_ptr_impl<T, U>::DeleterConstraint::type; 
 
    inner::__unique_ptr_data<T, Deleter> data_{}; 
 
public:
    using pointer = typename inner::__unique_ptr_impl<T, Deleter>::pointer; 
    using element_type = T;                                                 
    using deleter_type = Deleter;                                           
 
private:
    template <typename U, typename E, typename UP = unique_ptr<U, E>, typename UP_pointer = typename UP::pointer,
              typename UP_element_type = typename UP::element_type>
    using safe_conversion =
            conjunction<is_array<U>, is_same<pointer, element_type*>, is_same<UP_pointer, UP_element_type*>,
                        is_convertible<UP_element_type (*)[], element_type (*)[]>>;
 
    template <typename U>
    using safe_conversion_raw =
            conjunction<disjunction<disjunction<is_same<U, pointer>, is_same<U, nullptr_t>>,
                                    conjunction<is_pointer<U>, is_same<pointer, element_type*>,
                                                is_convertible<remove_pointer_t<U> (*)[], element_type (*)[]>>>>;
 
public:
    template <typename U, typename Del = Deleter, typename = DeleterConstraint<Del>,
              enable_if_t<safe_conversion_raw<U>::value, int> = 0>
    NEFORCE_CONSTEXPR20 explicit unique_ptr(U ptr) noexcept :
    data_(ptr) {}

    template <typename U, typename Del = deleter_type,
              enable_if_t<conjunction<safe_conversion_raw<U>, is_copy_constructible<Del>>::value, int> = 0>
    NEFORCE_CONSTEXPR20 unique_ptr(U ptr, const deleter_type& deleter) noexcept :
    data_(ptr, deleter) {}

    template <typename U, typename Del = deleter_type,
              enable_if_t<conjunction<safe_conversion_raw<U>, is_move_constructible<Del>>::value, int> = 0>
    NEFORCE_CONSTEXPR20 unique_ptr(U ptr, enable_if_t<!is_lvalue_reference<Del>::value, Del&&> deleter) noexcept :
    data_(_NEFORCE move(ptr), _NEFORCE move(deleter)) {}

    template <typename U, typename Del = deleter_type, typename DelMoveRef = remove_reference_t<Del>,
              enable_if_t<safe_conversion_raw<U>::value, int> = 0>
    unique_ptr(U, enable_if_t<is_lvalue_reference<Del>::value, DelMoveRef&&>) = delete;
 
    unique_ptr(unique_ptr&&) = default; 

    template <typename Del = Deleter, typename = DeleterConstraint<Del>>
    constexpr unique_ptr(nullptr_t = nullptr) noexcept {}

    template <typename U, typename E,
              enable_if_t<conjunction<safe_conversion<U, E>,
                                      conditional_t<is_reference<Deleter>::value, is_same<E, Deleter>,
                                                    is_convertible<E, Deleter>>>::value,
                          int> = 0>
    NEFORCE_CONSTEXPR20 unique_ptr(unique_ptr<U, E>&& other) noexcept :
    data_(other.release(), _NEFORCE forward<E>(other.get_deleter())) {}

    NEFORCE_CONSTEXPR20 ~unique_ptr() {
        auto& ptr = data_.get_ptr();
        if (ptr != nullptr) {
            get_deleter()(ptr);
        }
        ptr = pointer();
    }
 
    unique_ptr& operator=(unique_ptr&&) = default; 

    template <typename U, typename E,
              enable_if_t<conjunction_v<safe_conversion<U, E>, is_assignable<deleter_type&, E&&>>, int> = 0>
    NEFORCE_CONSTEXPR20 unique_ptr& operator=(unique_ptr<U, E>&& other) noexcept {
        unique_ptr::reset(other.release());
        get_deleter() = _NEFORCE forward<E>(other.get_deleter());
        return *this;
    }

    NEFORCE_CONSTEXPR20 unique_ptr& operator=(nullptr_t) noexcept {
        reset();
        return *this;
    }

    NEFORCE_CONSTEXPR20 add_lvalue_reference_t<element_type> operator[](size_t idx) const {
        NEFORCE_DEBUG_VERIFY(get() != pointer(), "_NEFORCE add_lvalue_reference_t<element_type> failed");
        return get()[idx];
    }

    NEFORCE_CONSTEXPR20 pointer get() const noexcept { return data_.get_ptr(); }

    NEFORCE_CONSTEXPR20 deleter_type& get_deleter() noexcept { return data_.get_deleter(); }

    NEFORCE_CONSTEXPR20 const deleter_type& get_deleter() const noexcept { return data_.get_deleter(); }

    NEFORCE_CONSTEXPR20 explicit operator bool() const noexcept { return get() != pointer(); }

    NEFORCE_CONSTEXPR20 pointer release() noexcept { return data_.release(); }

    template <typename U,
              enable_if_t<conjunction<disjunction<
                                  is_same<U, pointer>,
                                  conjunction<is_same<pointer, element_type*>, is_pointer<U>,
                                              is_convertible<remove_pointer_t<U> (*)[], element_type (*)[]>>>>::value,
                          int> = 0>
    NEFORCE_CONSTEXPR20 void reset(U ptr) noexcept {
        data_.reset(_NEFORCE move(ptr));
    }

    NEFORCE_CONSTEXPR20 void reset(nullptr_t = nullptr) noexcept { unique_ptr::reset(pointer()); }

    NEFORCE_CONSTEXPR20 void swap(unique_ptr& other) noexcept { data_.swap(other.data_); }
 
    unique_ptr(const unique_ptr&) = delete;            
    unique_ptr& operator=(const unique_ptr&) = delete; 
};

template <typename T, typename Deleter, enable_if_t<is_swappable<Deleter>::value && is_swappable<T>::value, int> = 0>
void swap(unique_ptr<T, Deleter>& lhs, unique_ptr<T, Deleter>& rhs) noexcept {
    lhs.swap(rhs);
}

template <typename T, typename D, typename U, typename E>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator==(const unique_ptr<T, D>& lhs, const unique_ptr<U, E>& rhs) {
    return lhs.get() == rhs.get();
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator==(const unique_ptr<T, D>& lhs, nullptr_t) {
    return !lhs;
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator==(nullptr_t, const unique_ptr<T, D>& rhs) {
    return !rhs;
}

template <typename T, typename D, typename U, typename E>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator!=(const unique_ptr<T, D>& lhs, const unique_ptr<U, E>& rhs) {
    return lhs.get() != rhs.get();
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator!=(const unique_ptr<T, D>& lhs, nullptr_t) {
    return static_cast<bool>(lhs);
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator!=(nullptr_t, const unique_ptr<T, D>& rhs) {
    return static_cast<bool>(rhs);
}

template <typename T, typename D, typename U, typename E>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator<(const unique_ptr<T, D>& lhs, const unique_ptr<U, E>& rhs) {
    using common_t = common_type_t<typename unique_ptr<T, D>::pointer, typename unique_ptr<U, E>::pointer>;
    return _NEFORCE less<common_t>()(lhs.get(), rhs.get());
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator<(const unique_ptr<T, D>& lhs, nullptr_t) {
    return _NEFORCE less<typename unique_ptr<T, D>::pointer>()(lhs.get(), nullptr);
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator<(nullptr_t, const unique_ptr<T, D>& rhs) {
    return _NEFORCE less<typename unique_ptr<T, D>::pointer>()(nullptr, rhs.get());
}

template <typename T, typename D, typename U, typename E>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator>(const unique_ptr<T, D>& lhs, const unique_ptr<U, E>& rhs) {
    return rhs.get() < lhs.get();
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator>(const unique_ptr<T, D>& lhs, nullptr_t) {
    return _NEFORCE less<typename unique_ptr<T, D>::pointer>()(nullptr, lhs.get());
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator>(nullptr_t, const unique_ptr<T, D>& rhs) {
    return _NEFORCE less<typename unique_ptr<T, D>::pointer>()(rhs.get(), nullptr);
}

template <typename T, typename D, typename U, typename E>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator<=(const unique_ptr<T, D>& lhs, const unique_ptr<U, E>& rhs) {
    return !(lhs > rhs);
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator<=(const unique_ptr<T, D>& lhs, nullptr_t) {
    return !(lhs > nullptr);
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator<=(nullptr_t, const unique_ptr<T, D>& rhs) {
    return !(nullptr > rhs);
}

template <typename T, typename D, typename U, typename E>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator>=(const unique_ptr<T, D>& lhs, const unique_ptr<U, E>& rhs) {
    return !(lhs < rhs);
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator>=(const unique_ptr<T, D>& lhs, nullptr_t) {
    return !(lhs < nullptr);
}

template <typename T, typename D>
NEFORCE_NODISCARD NEFORCE_CONSTEXPR20 bool operator>=(nullptr_t, const unique_ptr<T, D>& rhs) {
    return !(nullptr < rhs);
}
 

template <typename T, typename U, typename Deleter>
unique_ptr<T, Deleter> static_pointer_cast(const unique_ptr<U, Deleter>& ptr) = delete;

template <typename T, typename U, typename Deleter>
unique_ptr<T, Deleter> const_pointer_cast(const unique_ptr<U, Deleter>& ptr) = delete;

template <typename T, typename U, typename Deleter>
unique_ptr<T, Deleter> reinterpret_pointer_cast(const unique_ptr<U, Deleter>& ptr) = delete;

template <typename T, typename U, typename Deleter>
unique_ptr<T, Deleter> dynamic_pointer_cast(const unique_ptr<U, Deleter>& ptr) = delete;
 

template <typename T, typename DeleterT, typename U, typename DeleterU>
NEFORCE_CONSTEXPR20 unique_ptr<T, DeleterT> static_pointer_cast(unique_ptr<U, DeleterU>&& ptr) {
    DeleterU&& deleter = _NEFORCE move(ptr).get_deleter();
    return unique_ptr<T, DeleterT>(static_cast<T*>(ptr.release()), _NEFORCE move(deleter).template rebind<T>());
}

template <typename T, typename DeleterT, typename U, typename DeleterU>
NEFORCE_CONSTEXPR20 unique_ptr<T, DeleterT> const_pointer_cast(unique_ptr<U, DeleterU>&& ptr) {
    DeleterU&& deleter = _NEFORCE move(ptr).get_deleter();
    return unique_ptr<T, DeleterT>(const_cast<T*>(ptr.release()), _NEFORCE move(deleter).template rebind<T>());
}

template <typename T, typename DeleterT, typename U, typename DeleterU>
unique_ptr<T, DeleterT> reinterpret_pointer_cast(unique_ptr<U, DeleterU>&& ptr) {
    DeleterU&& deleter = _NEFORCE move(ptr).get_deleter();
    return unique_ptr<T, DeleterT>(reinterpret_cast<T*>(ptr.release()), _NEFORCE move(deleter).template rebind<T>());
}

template <typename T, typename DeleterT, typename U, typename DeleterU>
unique_ptr<T, DeleterT> dynamic_pointer_cast(unique_ptr<U, DeleterU>&& ptr) {
    T* tmp = dynamic_cast<T*>(ptr.get());
    if (tmp != nullptr) {
        (void) ptr.release();
        DeleterU&& deleter = _NEFORCE move(ptr).get_deleter();
        return {tmp, _NEFORCE move(deleter).template rebind<T>()};
    }
    DeleterU&& deleter = _NEFORCE move(ptr).get_deleter();
    return {nullptr, _NEFORCE move(deleter).template rebind<T>()};
}
 // UniquePointer


template <typename T, typename Deleter>
struct hash<unique_ptr<T, Deleter>> {
    NEFORCE_CONSTEXPR20 size_t operator()(const unique_ptr<T, Deleter>& ptr) const
            noexcept(noexcept(hash<T*>()(ptr.get()))) {
        return hash<T*>()(ptr.get());
    }
};
 // HashPrimary


template <typename T, typename... Args, enable_if_t<!is_array<T>::value, int> = 0>
NEFORCE_CONSTEXPR20 unique_ptr<T> make_unique(Args&&... args) {
    return unique_ptr<T>(new T(_NEFORCE forward<Args>(args)...));
}

template <typename T, enable_if_t<is_unbounded_array<T>::value, int> = 0>
NEFORCE_CONSTEXPR20 unique_ptr<T> make_unique(const size_t len) {
    return unique_ptr<T>(new remove_extent_t<T>[len]());
}

template <typename T, typename... Args, enable_if_t<is_bounded_array<T>::value, int> = 0>
unique_ptr<T> make_unique(Args&&...) = delete;
 // UniquePointer
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_MEMORY_UNIQUE_PTR_HPP__