Memory.h

#pragma once

#include <memory>
#include <utility>

namespace Euclid
{
template<typename T>
class ProPtr
{
public:
    using pointer = T*;
    using element_type = T;

public:
    constexpr ProPtr() noexcept : _data(nullptr), _own(false) {}

    constexpr ProPtr(std::nullptr_t) noexcept : _data(nullptr), _own(false) {}

    explicit ProPtr(pointer p, bool own = false) noexcept : _data(p), _own(own)
    {}

    ProPtr(const ProPtr& pro) = delete;

    ProPtr(ProPtr&& pro) noexcept
    {
        pro.swap(*this);
    }

    template<typename U>
    ProPtr(ProPtr<U>&& pro) noexcept
    {
        auto owning = pro.owns();
        auto data = pro.release();
        ProPtr<T> tmp(data, owning);
        tmp.swap(*this);
    }

    ~ProPtr()
    {
        if (_own) {
            delete _data;
        }
    }

    ProPtr& operator=(const ProPtr& pro) = delete;

    ProPtr& operator=(std::nullptr_t) noexcept
    {
        reset();
        return *this;
    }

    ProPtr& operator=(ProPtr&& pro) noexcept
    {
        pro.swap(*this);
        return *this;
    }

    template<typename U>
    ProPtr& operator=(ProPtr<U>&& pro) noexcept
    {
        auto owning = pro.owns();
        auto data = pro.release();
        ProPtr<T> tmp(data, owning);
        tmp.swap(*this);
        return *this;
    }

    pointer release() noexcept
    {
        pointer result = nullptr;
        std::swap(result, _data);
        _own = false;
        return result;
    }

    void reset(pointer p = pointer(), bool own = false) noexcept
    {
        if (_own) {
            delete _data;
        }
        _data = p;
        _own = own;
    }

    void swap(ProPtr& pro) noexcept
    {
        using std::swap;
        swap(pro._data, _data);
        swap(pro._own, _own);
    }

    pointer get() const noexcept
    {
        return _data;
    }

    explicit operator bool() const noexcept
    {
        return _data;
    }

    typename std::add_lvalue_reference<T>::type operator*() const
    {
        return *_data;
    }

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

    bool owns() const noexcept
    {
        return _own;
    }

private:
    pointer _data;
    bool _own;
};

template<typename T>
void swap(ProPtr<T>& lhs, ProPtr<T>& rhs)
{
    lhs.swap(rhs);
}

} // namespace Euclid