Reference.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Core/Atomics.h>
 
JPH_NAMESPACE_BEGIN
 
// Forward declares
template <class T> class Ref;
template <class T> class RefConst;
 
template <class T>
class RefTarget     
{   
public:
    inline                  RefTarget() = default;
    inline                  RefTarget(const RefTarget &)                    { /* Do not copy refcount */ }
    inline                  ~RefTarget()                                    { JPH_IF_ENABLE_ASSERTS(uint32 value = mRefCount.load(memory_order_relaxed);) JPH_ASSERT(value == 0 || value == cEmbedded); } 
 
    inline void             SetEmbedded() const                             { JPH_IF_ENABLE_ASSERTS(uint32 old = ) mRefCount.fetch_add(cEmbedded, memory_order_relaxed); JPH_ASSERT(old < cEmbedded); }
 
    inline RefTarget &      operator = (const RefTarget &)                  { /* Don't copy refcount */ return *this; }
 
    uint32                  GetRefCount() const                             { return mRefCount.load(memory_order_relaxed); }
 
    inline void             AddRef() const
    {
        // Adding a reference can use relaxed memory ordering
        mRefCount.fetch_add(1, memory_order_relaxed);
    }
 
    inline void             Release() const
    {
        // Releasing a reference must use release semantics...
        if (mRefCount.fetch_sub(1, memory_order_release) == 1)
        {
            // ... so that we can use aquire to ensure that we see any updates from other threads that released a ref before deleting the object
            atomic_thread_fence(memory_order_acquire);
            delete static_cast<const T *>(this);
        }
    }
 
    static int              sInternalGetRefCountOffset()                    { return offsetof(T, mRefCount); }
 
protected:
    static constexpr uint32 cEmbedded = 0x0ebedded;                         
 
    mutable atomic<uint32>  mRefCount = 0;                                  
};                          
 
class RefTargetVirtual
{
public:
    virtual                 ~RefTargetVirtual() = default;
 
    virtual void            AddRef() = 0;
 
    virtual void            Release() = 0;
};
 
template <class T>
class Ref
{
public:
    inline                  Ref()                                           : mPtr(nullptr) { }
    inline                  Ref(T *inRHS)                                   : mPtr(inRHS) { AddRef(); }
    inline                  Ref(const Ref<T> &inRHS)                        : mPtr(inRHS.mPtr) { AddRef(); }
    inline                  Ref(Ref<T> &&inRHS) noexcept                    : mPtr(inRHS.mPtr) { inRHS.mPtr = nullptr; }
    inline                  ~Ref()                                          { Release(); }
                        
    inline Ref<T> &         operator = (T *inRHS)                           { if (mPtr != inRHS) { Release(); mPtr = inRHS; AddRef(); } return *this; }
    inline Ref<T> &         operator = (const Ref<T> &inRHS)                { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; AddRef(); } return *this; }
    inline Ref<T> &         operator = (Ref<T> &&inRHS) noexcept            { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; inRHS.mPtr = nullptr; } return *this; }
                        
    inline                  operator T * const () const                     { return mPtr; }
    inline                  operator T *()                                  { return mPtr; }
                        
    inline T * const        operator -> () const                            { return mPtr; }
    inline T *              operator -> ()                                  { return mPtr; }
    inline T &              operator * () const                             { return *mPtr; }
 
    inline bool             operator == (const T * inRHS) const             { return mPtr == inRHS; }
    inline bool             operator == (const Ref<T> &inRHS) const         { return mPtr == inRHS.mPtr; }
    inline bool             operator != (const T * inRHS) const             { return mPtr != inRHS; }
    inline bool             operator != (const Ref<T> &inRHS) const         { return mPtr != inRHS.mPtr; }
 
    inline T *              GetPtr() const                                  { return mPtr; }
    inline T *              GetPtr()                                        { return mPtr; }
 
    void **                 InternalGetPointer()                            { return reinterpret_cast<void **>(&mPtr); }
 
private:
    template <class T2> friend class RefConst;
 
    inline void             AddRef()                                        { if (mPtr != nullptr) mPtr->AddRef(); }
    inline void             Release()                                       { if (mPtr != nullptr) mPtr->Release(); }
    
    T *                     mPtr;                                           
};                      
 
template <class T>
class RefConst
{
public:
    inline                  RefConst()                                      : mPtr(nullptr) { }
    inline                  RefConst(const T * inRHS)                       : mPtr(inRHS) { AddRef(); }
    inline                  RefConst(const RefConst<T> &inRHS)              : mPtr(inRHS.mPtr) { AddRef(); }
    inline                  RefConst(RefConst<T> &&inRHS) noexcept          : mPtr(inRHS.mPtr) { inRHS.mPtr = nullptr; }
    inline                  RefConst(const Ref<T> &inRHS)                   : mPtr(inRHS.mPtr) { AddRef(); }
    inline                  RefConst(Ref<T> &&inRHS) noexcept               : mPtr(inRHS.mPtr) { inRHS.mPtr = nullptr; }
    inline                  ~RefConst()                                     { Release(); }
                        
    inline RefConst<T> &    operator = (const T * inRHS)                    { if (mPtr != inRHS) { Release(); mPtr = inRHS; AddRef(); } return *this; }
    inline RefConst<T> &    operator = (const RefConst<T> &inRHS)           { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; AddRef(); } return *this; }
    inline RefConst<T> &    operator = (RefConst<T> &&inRHS) noexcept       { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; inRHS.mPtr = nullptr; } return *this; }
    inline RefConst<T> &    operator = (const Ref<T> &inRHS)                { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; AddRef(); } return *this; }
    inline RefConst<T> &    operator = (Ref<T> &&inRHS) noexcept            { if (mPtr != inRHS.mPtr) { Release(); mPtr = inRHS.mPtr; inRHS.mPtr = nullptr; } return *this; }
                        
    inline                  operator const T * () const                     { return mPtr; }
                        
    inline const T *        operator -> () const                            { return mPtr; }
    inline const T &        operator * () const                             { return *mPtr; }
 
    inline bool             operator == (const T * inRHS) const             { return mPtr == inRHS; }
    inline bool             operator == (const RefConst<T> &inRHS) const    { return mPtr == inRHS.mPtr; }
    inline bool             operator == (const Ref<T> &inRHS) const         { return mPtr == inRHS.mPtr; }
    inline bool             operator != (const T * inRHS) const             { return mPtr != inRHS; }
    inline bool             operator != (const RefConst<T> &inRHS) const    { return mPtr != inRHS.mPtr; }
    inline bool             operator != (const Ref<T> &inRHS) const         { return mPtr != inRHS.mPtr; }
 
    inline const T *        GetPtr() const                                  { return mPtr; }
 
    void **                 InternalGetPointer()                            { return const_cast<void **>(reinterpret_cast<const void **>(&mPtr)); }
 
private:
    inline void             AddRef()                                        { if (mPtr != nullptr) mPtr->AddRef(); }
    inline void             Release()                                       { if (mPtr != nullptr) mPtr->Release(); }
    
    const T *               mPtr;                                           
};                      
 
JPH_NAMESPACE_END
 
JPH_SUPPRESS_WARNING_PUSH
JPH_CLANG_SUPPRESS_WARNING("-Wc++98-compat")
 
namespace std
{
    template <class T> 
    struct hash<JPH::Ref<T>>
    {
        size_t operator () (const JPH::Ref<T> &inRHS) const
        {
            return hash<T *> { }(inRHS.GetPtr());
        }
    };
 
    template <class T> 
    struct hash<JPH::RefConst<T>>
    {
        size_t operator () (const JPH::RefConst<T> &inRHS) const
        {
            return hash<const T *> { }(inRHS.GetPtr());
        }
    };
}
 
JPH_SUPPRESS_WARNING_POP