AutoPtr.h

#pragma once


UTL_NS_BEGIN;



template <typename T = Object>
class AutoPtr
{
public:
    AutoPtr()
    {
        init();
    }

    AutoPtr(T* ptr, bool owner = true)
    {
        init();
        set(ptr, owner);
    }

    AutoPtr(AutoPtr<T>&& rhs) noexcept
    {
        init();
        steal(rhs);
    }

    template <typename NonT>
    AutoPtr(AutoPtr<NonT>&& rhs) noexcept
    {
        init();
        stealNonT(rhs);
    }

    ~AutoPtr()
    {
        deInit();
    }



    T*
    get() const
    {
        return _ptr;
    }

    bool
    isNull() const
    {
        return (_ptr == nullptr);
    }

    bool
    isOwner() const
    {
        return _owner;
    }



    void
    clear()
    {
        if (_owner) delete _ptr;
        _ptr = nullptr;
        _owner = false;
    }

    T*
    release()
    {
        _owner = false;
        return _ptr;
    }

    void
    set(T* ptr, bool owner = true)
    {
        if (ptr != _ptr)
        {
            if (_owner) delete _ptr;
            _ptr = ptr;
        }
        _owner = owner;
    }

    template <typename NonT>
    void
    setNonT(NonT* ptr, bool owner = true)
    {
        set(dynamic_cast<T*>(ptr), owner);
        ASSERTD(_ptr != nullptr);
    }



    void
    steal(AutoPtr<T>& rhs)
    {
        set(rhs.get(), rhs.isOwner());
        rhs.release();
    }

    template <typename NonT>
    void
    stealNonT(AutoPtr<NonT>& rhs)
    {
        setNonT(rhs.get(), rhs.isOwner());
        rhs.release();
    }

    AutoPtr<T>& operator=(AutoPtr<T>&& rhs) noexcept
    {
        steal(rhs);
        return self;
    }

    template <typename NonT>
    AutoPtr<T>& operator=(const AutoPtr<NonT>&& rhs) noexcept
    {
        steal(rhs);
        return self;
    }

    AutoPtr<T>& operator=(T* ptr)
    {
        set(ptr);
        return self;
    }

    template <typename NonT>
    AutoPtr<T>& operator=(NonT* ptr)
    {
        setNonT(ptr);
        return self;
    }



    T& operator*() const
    {
        return *ptr();
    }

    T* operator->() const
    {
        return ptr();
    }

    operator T*() const
    {
        return _ptr;
    }
protected:
    T*
    ptr() const
    {
        ASSERTD(_ptr != nullptr);
        return _ptr;
    }

protected:
    T* _ptr;
    bool _owner;

private:
    void
    init()
    {
        _ptr = nullptr;
        _owner = false;
    }
    void
    deInit()
    {
        if (_owner) delete _ptr;
    }
};


UTL_NS_END;


template <typename X, typename Y>
bool operator==(const utl::AutoPtr<X>& lhs, const utl::AutoPtr<Y>& rhs)
{
    return (lhs.get() == rhs.get());
}

template <typename T>
bool operator==(const utl::AutoPtr<T>& lhs, std::nullptr_t rhs)
{
    return (lhs.get() == nullptr);
}

template <typename T>
bool operator==(std::nullptr_t lhs, const utl::AutoPtr<T>& rhs)
{
    return (rhs.get() == nullptr);
}

template <typename X, typename Y>
bool operator!=(const utl::AutoPtr<X>& lhs, const utl::AutoPtr<Y>& rhs)
{
    return (lhs.get() != rhs.get());
}

template <typename T>
bool operator!=(const utl::AutoPtr<T>& lhs, std::nullptr_t rhs)
{
    return (lhs.get() != nullptr);
}

template <typename T>
bool operator!=(std::nullptr_t lhs, const utl::AutoPtr<T>& rhs)
{
    return (rhs.get() != nullptr);
}