RefCounted.h

 
#pragma once
 
#include <Foundation/Threading/AtomicUtils.h>
 
class PL_FOUNDATION_DLL plRefCountingImpl
{
public:
  plRefCountingImpl() = default;                  // [tested]
 
  plRefCountingImpl(const plRefCountingImpl& rhs) // [tested]
  {
    // do not copy the ref count
  }
 
  void operator=(const plRefCountingImpl& rhs) // [tested]
  {
    // do not copy the ref count
  }
 
  inline plInt32 AddRef() const // [tested]
  {
    return plAtomicUtils::Increment(m_iRefCount);
  }
 
  inline plInt32 ReleaseRef() const // [tested]
  {
    return plAtomicUtils::Decrement(m_iRefCount);
  }
 
  inline bool IsReferenced() const // [tested]
  {
    return m_iRefCount > 0;
  }
 
  inline plInt32 GetRefCount() const // [tested]
  {
    return m_iRefCount;
  }
 
private:
  mutable plInt32 m_iRefCount = 0; 
};
 
class PL_FOUNDATION_DLL plRefCounted : public plRefCountingImpl
{
public:
  virtual ~plRefCounted() = default;
};
 
template <typename T>
class plScopedRefPointer
{
public:
  plScopedRefPointer()
    : m_pReferencedObject(nullptr)
  {
  }
 
  plScopedRefPointer(T* pReferencedObject)
    : m_pReferencedObject(pReferencedObject)
  {
    AddReferenceIfValid();
  }
 
  plScopedRefPointer(const plScopedRefPointer<T>& other)
  {
    m_pReferencedObject = other.m_pReferencedObject;
 
    AddReferenceIfValid();
  }
 
  ~plScopedRefPointer() { ReleaseReferenceIfValid(); }
 
  void operator=(T* pNewReference)
  {
    if (pNewReference == m_pReferencedObject)
      return;
 
    ReleaseReferenceIfValid();
 
    m_pReferencedObject = pNewReference;
 
    AddReferenceIfValid();
  }
 
  void operator=(const plScopedRefPointer<T>& other)
  {
    if (other.m_pReferencedObject == m_pReferencedObject)
      return;
 
    ReleaseReferenceIfValid();
 
    m_pReferencedObject = other.m_pReferencedObject;
 
    AddReferenceIfValid();
  }
 
  operator const T*() const { return m_pReferencedObject; }
 
  operator T*() { return m_pReferencedObject; }
 
  const T* operator->() const
  {
    PL_ASSERT_DEV(m_pReferencedObject != nullptr, "Pointer is nullptr.");
    return m_pReferencedObject;
  }
 
  T* operator->()
  {
    PL_ASSERT_DEV(m_pReferencedObject != nullptr, "Pointer is nullptr.");
    return m_pReferencedObject;
  }
 
private:
  inline void AddReferenceIfValid()
  {
    if (m_pReferencedObject != nullptr)
    {
      m_pReferencedObject->AddRef();
    }
  }
 
  inline void ReleaseReferenceIfValid()
  {
    if (m_pReferencedObject != nullptr)
    {
      m_pReferencedObject->ReleaseRef();
    }
  }
 
  T* m_pReferencedObject; 
};
 
 
template <typename TYPE>
class plRefCountedContainer : public plRefCounted
{
public:
  TYPE m_Content;
};