Class unique_ptr

src/fl/stl/unique_ptr.h:36–126

template<typename T, typename Deleter = default_delete<T>>
class unique_ptr {
public:
    using element_type = T;
    using deleter_type = Deleter;
    using pointer = T*;

private:
    pointer mPtr;
    Deleter mDeleter;

public:
    // Constructors
    constexpr unique_ptr() FL_NOEXCEPT : mPtr(nullptr), mDeleter() {}
    constexpr unique_ptr(fl::nullptr_t) FL_NOEXCEPT : mPtr(nullptr), mDeleter() {}
    explicit unique_ptr(pointer p) FL_NOEXCEPT : mPtr(p), mDeleter() {}
    unique_ptr(pointer p, const Deleter& d) FL_NOEXCEPT : mPtr(p), mDeleter(d) {}
    unique_ptr(pointer p, Deleter&& d) FL_NOEXCEPT : mPtr(p), mDeleter(fl::move(d)) {}
    
    // Move constructor
    unique_ptr(unique_ptr&& u) FL_NOEXCEPT : mPtr(u.release()), mDeleter(fl::move(u.mDeleter)) {}
    
    // Converting move constructor
    template<typename U, typename E>
    unique_ptr(unique_ptr<U, E>&& u) FL_NOEXCEPT 
        : mPtr(u.release()), mDeleter(fl::move(u.get_deleter())) {}
    
    // Copy semantics deleted
    unique_ptr(const unique_ptr&) FL_NOEXCEPT = delete;
    unique_ptr& operator=(const unique_ptr&) FL_NOEXCEPT = delete;
    
    // Move assignment
    unique_ptr& operator=(unique_ptr&& u) FL_NOEXCEPT {
        if (this != &u) {
            reset(u.release());
            mDeleter = fl::move(u.mDeleter);
        }
        return *this;
    }
    
    // Converting move assignment
    template<typename U, typename E>
    unique_ptr& operator=(unique_ptr<U, E>&& u) FL_NOEXCEPT {
        reset(u.release());
        mDeleter = fl::move(u.get_deleter());
        return *this;
    }
    
    // nullptr assignment
    unique_ptr& operator=(fl::nullptr_t) FL_NOEXCEPT {
        reset();
        return *this;
    }
    
    // Destructor
    ~unique_ptr() FL_NOEXCEPT {
        if (mPtr) {
            mDeleter(mPtr);
        }