RefPtr.h

Go to the documentation of this file.

/*
* SPDX-FileCopyrightText: Copyright (c) 2020-2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
* SPDX-License-Identifier: MIT
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
 
 
#ifndef NVNEURAL_REFPTR_H
#define NVNEURAL_REFPTR_H
 
#include <nvneural/CoreTypes.h>
 
#include <type_traits>
#include <utility>
 
namespace nvneural {
 
template<typename TObject>
class RefPtr
{
    // Sanity-check the template parameter
    static_assert(std::is_convertible<TObject*, const IRefObject*>::value, "Object must inherit from nvneural::IRefObject");
 
public:
    RefPtr() noexcept
        : m_pObject{nullptr}
    {
    }
 
    static RefPtr fromPointer(TObject* pObject)
    {
        RefPtr pResult;
        pResult.m_pObject = pObject;
        pResult.safeAddRef();
        return pResult;
    }
 
    static RefPtr fromPointerNoAddRef(TObject* pObject)
    {
        RefPtr pResult;
        pResult.m_pObject = pObject;
        return pResult;
    }
 
    RefPtr(const RefPtr& copyFrom) noexcept
        : m_pObject{copyFrom.m_pObject}
    {
        safeAddRef();
    }
 
    RefPtr(RefPtr&& moveFrom) noexcept
        : m_pObject{nullptr}
    {
        std::swap(m_pObject, moveFrom.m_pObject);
 
        // Object maintains current reference count;
        // old object released when moveFrom is destroyed
    }
 
    ~RefPtr()
    {
        safeRelease();
    }
 
    RefPtr& operator =(const RefPtr& copyFrom) noexcept
    {
        const auto pOldObject = std::exchange(m_pObject, copyFrom.m_pObject);
        safeAddRef();
        if (pOldObject)
        {
            pOldObject->release();
        }
        return *this;
    }
 
    RefPtr& operator =(RefPtr&& moveFrom) noexcept
    {
        std::swap(m_pObject, moveFrom.m_pObject);
 
        // Object maintains current reference count;
        // old object released when moveFrom is destroyed
 
        return *this;
    }
 
    RefPtr& operator =(std::nullptr_t) noexcept
    {
        safeRelease();
 
        m_pObject = nullptr;
 
        return *this;
    }
 
    TObject* get() const noexcept
    {
        return m_pObject;
    }
 
    TObject* detach() noexcept
    {
        return std::exchange(m_pObject, nullptr);
    }
 
    TObject& operator *() const noexcept
    {
        return *m_pObject;
    }
 
    TObject* operator ->() const noexcept
    {
        return m_pObject;
    }
 
    explicit operator bool() const noexcept
    {
        return m_pObject != nullptr;
    }
 
    template<typename TDestinationObject>
    RefPtr<TDestinationObject> as() const noexcept
    {
        if (!m_pObject)
        {
            return RefPtr<TDestinationObject>();
        }
 
        const auto destinationInterface = InterfaceOf<TDestinationObject>::value;
        const auto pRawObject = m_pObject->queryInterface(destinationInterface);
        return RefPtr<TDestinationObject>::fromPointerNoAddRef(static_cast<TDestinationObject*>(pRawObject));
    }
 
    bool operator ==(const RefPtr<TObject>& other) const noexcept
    {
        return m_pObject == other.m_pObject;
    }
 
    bool operator ==(const TObject* pOther) const noexcept
    {
        return m_pObject == pOther;
    }
 
    bool operator !=(const RefPtr<TObject>& other) const noexcept
    {
        return m_pObject != other.m_pObject;
    }
 
    bool operator !=(const TObject* pOther) const noexcept
    {
        return m_pObject != pOther;
    }
 
    class OutputWrapper
    {
        friend class RefPtr;
 
    private:
        RefPtr& m_parent;
 
        explicit OutputWrapper(RefPtr& parent)
            : m_parent(parent)
        {
        }
 
    public:
        ~OutputWrapper()
        {
            // Force another queryInterface call to ensure the interface is what we think it is
            m_parent = m_parent.as<TObject>();
        }
 
        operator TObject**()
        {
            return &m_parent.m_pObject;
        }
    };
 
    class GenericOutputWrapper
    {
        friend class RefPtr;
 
    private:
        RefPtr& m_parent;
        IRefObject* m_pBuffer;
 
        explicit GenericOutputWrapper(RefPtr& parent)
            : m_parent(parent)
            , m_pBuffer(nullptr)
        {
        }
 
    public:
        ~GenericOutputWrapper()
        {
            m_parent = RefPtr<IRefObject>::fromPointerNoAddRef(m_pBuffer).as<TObject>();
        }
 
        operator IRefObject**()
        {
            return &m_pBuffer;
        }
    };
 
    friend class OutputWrapper;
    friend class GenericOutputWrapper;
 
    OutputWrapper put() & noexcept
    {
        safeRelease();
        m_pObject = nullptr;
        return OutputWrapper(*this);
    }
 
    GenericOutputWrapper put_refobject() & noexcept
    {
        safeRelease();
        m_pObject = nullptr;
        return GenericOutputWrapper(*this);
    }
 
private:
    TObject* m_pObject;
 
    void safeAddRef() const noexcept
    {
        if (m_pObject)
        {
            m_pObject->addRef();
        }
    }
 
    void safeRelease() const noexcept
    {
        if (m_pObject)
        {
            m_pObject->release();
        }
    }
};
 
template<typename TObject, typename TIntermediate = void, typename... TArguments>
inline RefPtr<IRefObject> make_refobject(TArguments&&... args) noexcept
{
    try
    {
        return RefPtr<IRefObject>::fromPointerNoAddRef(static_cast<IRefObject*>(static_cast<TIntermediate*>(new TObject(std::forward<TArguments>(args)...))));
    }
    catch (...)
    {
        return RefPtr<IRefObject>();
    }
}
 
} // namespace nvneural
 
namespace std
{
    template<typename TObject> struct hash<nvneural::RefPtr<TObject>>
    {
        std::size_t operator ()(const nvneural::RefPtr<TObject>& pObject) const noexcept
        {
            // Our hash algorithm: Reinterpret the underlying pointer as a size_t.
            //
            // Requirements of a std::hash function:
            //
            // 1: Takes a single parameter of the appropriate type. (obvious)
            // 2: Returns a size_t that represents the value of the parameter.
            //    (The size_t type is equivalent to uintptr_t on our supported platforms,
            //    so we can convert a pointer to size_t without losing bits.)
            // 3: Does not throw. (RefPtr<T>::get is noexcept, so we're good here.)
            // 4: Hash of equal values is equal. (RefPtr<T> objects are equal if their
            //    underlying pointers are equal, so we preserve that relationship.)
            // 5: Probability of unequal values hashing equally should be low. (Our
            //    hash is 1:1 with all possible values, so P(collision) is zero.)
            return reinterpret_cast<std::size_t>(pObject.get());
        }
    };
} // namespace std
 
#endif // NVNEURAL_REFPTR_H