DynamicArray.h

#pragma once
 
#include <Foundation/Containers/ArrayBase.h>
#include <Foundation/Memory/AllocatorWrapper.h>
#include <Foundation/Types/PointerWithFlags.h>
 
template <typename T>
class plDynamicArrayBase : public plArrayBase<T, plDynamicArrayBase<T>>
{
protected:
  explicit plDynamicArrayBase(plAllocator* pAllocator);                                 // [tested]
 
  plDynamicArrayBase(T* pInplaceStorage, plUInt32 uiCapacity, plAllocator* pAllocator); // [tested]
 
  plDynamicArrayBase(const plDynamicArrayBase<T>& other, plAllocator* pAllocator); // [tested]
 
  plDynamicArrayBase(plDynamicArrayBase<T>&& other, plAllocator* pAllocator); // [tested]
 
  plDynamicArrayBase(const plArrayPtr<const T>& other, plAllocator* pAllocator); // [tested]
 
  ~plDynamicArrayBase(); // [tested]
 
  void operator=(const plDynamicArrayBase<T>& rhs); // [tested]
 
  void operator=(plDynamicArrayBase<T>&& rhs) noexcept; // [tested]
 
  T* GetElementsPtr();
  const T* GetElementsPtr() const;
 
  friend class plArrayBase<T, plDynamicArrayBase<T>>;
 
public:
  void Reserve(plUInt32 uiCapacity); // [tested]
 
  void Compact(); // [tested]
 
  plAllocator* GetAllocator() const { return const_cast<plAllocator*>(m_pAllocator.GetPtr()); }
 
  plUInt64 GetHeapMemoryUsage() const; // [tested]
 
  void Swap(plDynamicArrayBase<T>& other); // [tested]
 
private:
  enum Storage
  {
    Owned = 0,
    External = 1
  };
 
  plPointerWithFlags<plAllocator, 1> m_pAllocator;
 
  enum
  {
    CAPACITY_ALIGNMENT = 16
  };
 
  void SetCapacity(plUInt32 uiCapacity);
};
 
template <typename T, typename AllocatorWrapper = plDefaultAllocatorWrapper>
class plDynamicArray : public plDynamicArrayBase<T>
{
public:
  PL_DECLARE_MEM_RELOCATABLE_TYPE();
 
 
  plDynamicArray();
  explicit plDynamicArray(plAllocator* pAllocator);
 
  plDynamicArray(const plDynamicArray<T, AllocatorWrapper>& other);
  plDynamicArray(const plDynamicArrayBase<T>& other);
  explicit plDynamicArray(const plArrayPtr<const T>& other);
 
  plDynamicArray(plDynamicArray<T, AllocatorWrapper>&& other);
  plDynamicArray(plDynamicArrayBase<T>&& other);
 
  void operator=(const plDynamicArray<T, AllocatorWrapper>& rhs);
  void operator=(const plDynamicArrayBase<T>& rhs);
  void operator=(const plArrayPtr<const T>& rhs);
 
  void operator=(plDynamicArray<T, AllocatorWrapper>&& rhs) noexcept;
  void operator=(plDynamicArrayBase<T>&& rhs) noexcept;
 
protected:
  plDynamicArray(T* pInplaceStorage, plUInt32 uiCapacity, plAllocator* pAllocator)
    : plDynamicArrayBase<T>(pInplaceStorage, uiCapacity, pAllocator)
  {
  }
};
 
template <typename T, typename AllocatorWrapper>
plArrayPtr<const T* const> plMakeArrayPtr(const plDynamicArray<T*, AllocatorWrapper>& dynArray);
 
template <typename T, typename AllocatorWrapper>
plArrayPtr<const T> plMakeArrayPtr(const plDynamicArray<T, AllocatorWrapper>& dynArray);
 
template <typename T, typename AllocatorWrapper>
plArrayPtr<T> plMakeArrayPtr(plDynamicArray<T, AllocatorWrapper>& in_dynArray);
 
 
static_assert(plGetTypeClass<plDynamicArray<int>>::value == 2, "dynamic array is not memory relocatable");
 
#include <Foundation/Containers/Implementation/DynamicArray_inl.h>