UniquePtr.h

#pragma once
 
#include <Foundation/Basics.h>
#include <Foundation/Memory/Allocator.h>
 
template <typename T>
class plUniquePtr
{
  PL_DISALLOW_COPY_AND_ASSIGN(plUniquePtr);
 
public:
  PL_DECLARE_MEM_RELOCATABLE_TYPE();
 
  plUniquePtr();
 
  template <typename U>
  plUniquePtr(const plInternal::NewInstance<U>& instance);
 
  template <typename U>
  plUniquePtr(U* pInstance, plAllocator* pAllocator);
 
  template <typename U>
  plUniquePtr(plUniquePtr<U>&& other);
 
  plUniquePtr(std::nullptr_t);
 
  ~plUniquePtr();
 
  template <typename U>
  plUniquePtr<T>& operator=(const plInternal::NewInstance<U>& instance);
 
  template <typename U>
  plUniquePtr<T>& operator=(plUniquePtr<U>&& other);
 
  plUniquePtr<T>& operator=(std::nullptr_t);
 
  T* Release();
 
  T* Release(plAllocator*& out_pAllocator);
 
  T* Borrow() const;
 
  void Clear();
 
  T& operator*() const;
 
  T* operator->() const;
 
  explicit operator bool() const;
 
  bool operator==(const plUniquePtr<T>& rhs) const;
  bool operator!=(const plUniquePtr<T>& rhs) const;
  bool operator<(const plUniquePtr<T>& rhs) const;
  bool operator<=(const plUniquePtr<T>& rhs) const;
  bool operator>(const plUniquePtr<T>& rhs) const;
  bool operator>=(const plUniquePtr<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;
 
private:
  template <typename U>
  friend class plUniquePtr;
 
  T* m_pInstance = nullptr;
  plAllocator* m_pAllocator = nullptr;
};
 
#include <Foundation/Types/Implementation/UniquePtr_inl.h>