SharedPtr.h

#pragma once
 
#include <Foundation/Types/RefCounted.h>
#include <Foundation/Types/UniquePtr.h>
 
template <typename T>
class plSharedPtr
{
public:
  PL_DECLARE_MEM_RELOCATABLE_TYPE();
 
  plSharedPtr();
 
  template <typename U>
  plSharedPtr(const plInternal::NewInstance<U>& instance);
 
  template <typename U>
  plSharedPtr(U* pInstance, plAllocator* pAllocator);
 
  plSharedPtr(const plSharedPtr<T>& other);
 
  template <typename U>
  plSharedPtr(const plSharedPtr<U>& other);
 
  template <typename U>
  plSharedPtr(plSharedPtr<U>&& other);
 
  template <typename U>
  plSharedPtr(plUniquePtr<U>&& other);
 
  plSharedPtr(std::nullptr_t);
 
  ~plSharedPtr();
 
  template <typename U>
  plSharedPtr<T>& operator=(const plInternal::NewInstance<U>& instance);
 
  plSharedPtr<T>& operator=(const plSharedPtr<T>& other);
 
  template <typename U>
  plSharedPtr<T>& operator=(const plSharedPtr<U>& other);
 
  template <typename U>
  plSharedPtr<T>& operator=(plSharedPtr<U>&& other);
 
  template <typename U>
  plSharedPtr<T>& operator=(plUniquePtr<U>&& other);
 
  plSharedPtr<T>& operator=(std::nullptr_t);
 
  T* Borrow() const;
 
  void Clear();
 
  T& operator*() const;
 
  T* operator->() const;
 
  operator const T*() const;
 
  operator T*();
 
  explicit operator bool() const;
 
  bool operator==(const plSharedPtr<T>& rhs) const;
  bool operator!=(const plSharedPtr<T>& rhs) const;
  bool operator<(const plSharedPtr<T>& rhs) const;
  bool operator<=(const plSharedPtr<T>& rhs) const;
  bool operator>(const plSharedPtr<T>& rhs) const;
  bool operator>=(const plSharedPtr<T>& rhs) const;
 
  bool operator==(std::nullptr_t) const;
  bool operator!=(std::nullptr_t) const;
  bool operator<(std::nullptr_t) const;
  bool operator<=(std::nullptr_t) const;
  bool operator>(std::nullptr_t) const;
  bool operator>=(std::nullptr_t) const;
 
  template <typename DERIVED>
  plSharedPtr<DERIVED> Downcast() const
  {
    return plSharedPtr<DERIVED>(static_cast<DERIVED*>(m_pInstance), m_pAllocator);
  }
 
private:
  template <typename U>
  friend class plSharedPtr;
 
  void AddReferenceIfValid();
  void ReleaseReferenceIfValid();
 
  T* m_pInstance;
  plAllocator* m_pAllocator;
};
 
#include <Foundation/Types/Implementation/SharedPtr_inl.h>