owned_or_borrowed_ptr.h

Go to the documentation of this file.

#ifndef OOKII_OWNED_OR_BORROWED_PTR_H_
#define OOKII_OWNED_OR_BORROWED_PTR_H_
 
#pragma once
 
#include <algorithm>
 
namespace ookii
{
    template<typename T>
    class owned_or_borrowed_ptr
    {
    public:
        using element_type = T;
        using pointer = T*;
        using reference = std::add_lvalue_reference_t<T>;
 
        owned_or_borrowed_ptr() noexcept = default;
 
        owned_or_borrowed_ptr(std::nullptr_t) noexcept {}
 
        owned_or_borrowed_ptr(pointer ptr, bool owned = true) noexcept
            : _ptr{ptr},
              _owned{owned}
        {
        }
 
        ~owned_or_borrowed_ptr()
        {
            reset();
        }
 
        owned_or_borrowed_ptr(const owned_or_borrowed_ptr &) = delete;
 
        owned_or_borrowed_ptr(owned_or_borrowed_ptr &&other) noexcept
            : _ptr{other.release()},
              _owned{other.is_owned()}
        {
        }
 
        template<typename T2, typename = std::enable_if_t<std::is_convertible_v<T2*, pointer>>>
        owned_or_borrowed_ptr(owned_or_borrowed_ptr<T2> &&other) noexcept
            : _ptr{other.release()},
              _owned{other.is_owned()}
        {
        }
 
        owned_or_borrowed_ptr &operator=(const owned_or_borrowed_ptr &) = delete;
 
        owned_or_borrowed_ptr &operator=(owned_or_borrowed_ptr &&other) noexcept
        {
            if (this != std::addressof(other))
            {
                reset(other.release(), other.is_owned());
            }
 
            return *this;
        }
 
        template<typename T2, typename = std::enable_if_t<std::is_convertible_v<T2*, pointer>>>
        owned_or_borrowed_ptr &operator=(owned_or_borrowed_ptr<T2> &&other) noexcept
        {
            if (this != std::addressof(other))
            {
                reset(other.release(), other.is_owned());
            }
 
            return *this;
        }
 
        owned_or_borrowed_ptr &operator=(std::nullptr_t) noexcept
        {
            reset();
            return *this;
        }
 
        explicit operator bool() const noexcept
        {
            return _ptr != nullptr;
        }
 
        void swap(owned_or_borrowed_ptr &other) noexcept
        {
            std::swap(_ptr, other._ptr);
            std::swap(_owned, other._owned);
        }
 
        pointer get() const noexcept
        {
            return _ptr;
        }
 
        bool is_owned() const noexcept
        {
            return _owned;
        }
 
        reference operator*() const noexcept
        {
            return *get();
        }
 
        pointer operator->() const noexcept
        {
            return get();
        }
 
        void reset(pointer ptr = nullptr, bool owned = true) noexcept
        {
            if (_owned && _ptr != nullptr)
                delete _ptr;
 
            _ptr = ptr;
            _owned = owned;
        }
 
        void reset(std::nullptr_t) noexcept
        {
            reset();
        }
 
        pointer release() noexcept
        {
            return std::exchange(_ptr, nullptr);
        }
 
        owned_or_borrowed_ptr as_borrowed() const noexcept
        {
            return {_ptr, false};
        }
 
    private:
        pointer _ptr{};
        bool _owned{};
    };
 
    template<typename T>
    void swap(owned_or_borrowed_ptr<T> &left, owned_or_borrowed_ptr<T> &right) noexcept
    {
        left.swap(right);
    }
 
    template<typename T, typename... Args>
    [[nodiscard]] auto make_owned_ptr(Args&&... args)
    {
        return owned_or_borrowed_ptr<T>(new T{std::forward<Args>(args)...});
    }
}
 
#endif