ptr.h

// Copyright 2018-present Network Optix, Inc. Licensed under MPL 2.0: www.mozilla.org/MPL/2.0/

#pragma once

#include <cstddef>
#include <type_traits>
#include <utility>

namespace nx {
namespace sdk {

template<class RefCountable>
class Ptr final
{
public:
    Ptr(std::nullptr_t = nullptr)
    {
        // This assertion needs to be placed in any method because it uses sizeof().
        static_assert(sizeof(Ptr<RefCountable>) == sizeof(RefCountable*),
            "Ptr layout should be the same as of a raw pointer.");
    }

    explicit Ptr(RefCountable* ptr): m_ptr(ptr) {}

    template<class OtherRefCountable>
    explicit Ptr(OtherRefCountable* ptr): m_ptr(ptr) {}

    template<class OtherRefCountable>
    Ptr(const Ptr<OtherRefCountable>& other): m_ptr(other.get()) { addRef(); }

    Ptr(const Ptr& other): m_ptr(other.get()) { addRef(); }

    template<class OtherRefCountable>
    Ptr(Ptr<OtherRefCountable>&& other): m_ptr(other.releasePtr()) {}

    Ptr(Ptr&& other) noexcept: m_ptr(other.releasePtr()) {}

    template<class OtherRefCountable>
    Ptr& operator=(const Ptr<OtherRefCountable>& other) { return assignConst(other); }

    Ptr& operator=(const Ptr& other) { return assignConst(other); }

    template<class OtherRefCountable>
    Ptr& operator=(Ptr<OtherRefCountable>&& other) { return assignRvalue(std::move(other)); }

    Ptr& operator=(Ptr&& other) noexcept { return assignRvalue(std::move(other)); }

    ~Ptr() { releaseRef(); }

    template<class OtherRefCountable>
    bool operator==(const Ptr<OtherRefCountable>& other) const { return m_ptr == other.get(); }

    template<class OtherRefCountable>
    bool operator!=(const Ptr<OtherRefCountable>& other) const { return !operator==(other); }

    void reset()
    {
        releaseRef();
        m_ptr = nullptr;
    }

    template<class OtherRefCountable>
    void reset(OtherRefCountable* ptr)
    {
        releaseRef();
        m_ptr = ptr;
    }

    RefCountable* releasePtr()
    {
        RefCountable* result = m_ptr;
        m_ptr = nullptr;
        return result;
    }

    RefCountable* get() const { return m_ptr;  }
    RefCountable* operator->() const { return m_ptr; }
    RefCountable& operator*() const { return *m_ptr; }

    explicit operator bool() const { return m_ptr != nullptr; }

private:
    void addRef()
    {
        if (m_ptr)
            m_ptr->addRef();
    }

    void releaseRef()
    {
        if (m_ptr)
            m_ptr->releaseRef();
    }

    Ptr& assignConst(const Ptr& other)
    {
        if (this != &other && m_ptr != other.get())
        {
            releaseRef();
            m_ptr = other.get();
            addRef();
        }
        return *this;
    }

    Ptr& assignRvalue(Ptr&& other)
    {
        if (this != &other && m_ptr != other.get())
        {
            releaseRef();
            m_ptr = other.releasePtr();
        }
        return *this;
    }

private:
    RefCountable* m_ptr = nullptr;
};

template<class RefCountable, typename Object>
bool operator==(const Ptr<RefCountable>& ptr, Object* p) { return ptr.get() == p; }

template<typename Object, class RefCountable>
bool operator==(Object* p, const Ptr<RefCountable>& ptr) { return p == ptr.get(); }

template<class RefCountable, typename Object>
bool operator!=(const Ptr<RefCountable>& ptr, Object* p) { return ptr.get() != p; }

template<typename Object, class RefCountable>
bool operator!=(Object* p, const Ptr<RefCountable>& ptr) { return p != ptr.get(); }

template<class RefCountable>
bool operator==(const Ptr<RefCountable>& ptr, std::nullptr_t) { return !ptr; }

template<class RefCountable>
bool operator==(std::nullptr_t, const Ptr<RefCountable>& ptr) { return !ptr; }

template<class RefCountable>
bool operator!=(const Ptr<RefCountable>& ptr, std::nullptr_t) { return (bool) ptr; }

template<class RefCountable>
bool operator!=(std::nullptr_t, const Ptr<RefCountable>& ptr) { return (bool) ptr; }

template<typename First, typename Second>
bool operator<(const Ptr<First>& first, const Ptr<Second>& second)
{
    return first.get() < second.get();
}

template<typename RefCountable>
bool operator<(const Ptr<RefCountable>& refCountable, std::nullptr_t)
{
    return refCountable.get() < nullptr;
}

template<typename RefCountable>
bool operator<(std::nullptr_t, const Ptr<RefCountable>& refCountable)
{
    return nullptr < refCountable.get();
}

template<typename First, typename Second>
bool operator<(const Ptr<First>& first, const Second* second)
{
    return first.get() < second;
}

template<typename First, typename Second>
bool operator<(const First* first, const Ptr<Second>& second)
{
    return first < second.get();
}

template<class RefCountable>
static Ptr<RefCountable> shareToPtr(RefCountable* refCountable)
{
    if (refCountable)
        refCountable->addRef();
    return Ptr(refCountable);
}

template<class RefCountable>
static Ptr<RefCountable> shareToPtr(const Ptr<RefCountable>& ptr)
{
    return ptr; //< Invoke the copy constructor.
}

template<class RefCountable, typename... Args>
static Ptr<RefCountable> makePtr(Args&&... args)
{
    return Ptr(new RefCountable(std::forward<Args>(args)...));
}

template</*explicit*/ class NewRefCountable, /*deduced*/ class OldRefCountable>
static Ptr<NewRefCountable> reinterpretPtr(const Ptr<OldRefCountable>& ptr)
{
    return shareToPtr(reinterpret_cast<NewRefCountable*>(ptr.get()));
}

template</*explicit*/ class Interface, /*deduced*/ class RefCountablePtr,
    /*deduced*/ typename OldInterfaceId>
static Ptr<Interface> queryInterfaceOfOldSdk(
    RefCountablePtr refCountable, const OldInterfaceId& interfaceId)
{
    return refCountable
        ? Ptr(static_cast<Interface*>(refCountable->queryInterface(interfaceId)))
        : nullptr;
}

template<class RefCountable>
static int refCount(const Ptr<RefCountable>& ptr)
{
    return refCount(ptr.get());
}

} // namespace sdk
} // namespace nx