SmallArray.h

#pragma once
 
#include <Foundation/Algorithm/Sorting.h>
#include <Foundation/Math/Math.h>
#include <Foundation/Memory/AllocatorWrapper.h>
#include <Foundation/Types/ArrayPtr.h>
 
constexpr plUInt32 plSmallInvalidIndex = 0xFFFF;
 
template <typename T, plUInt16 Size>
class plSmallArrayBase
{
public:
  // Only if the stored type is either POD or relocatable the hybrid array itself is also relocatable.
  PL_DECLARE_MEM_RELOCATABLE_TYPE_CONDITIONAL(T);
 
  plSmallArrayBase();                                                                // [tested]
  plSmallArrayBase(const plSmallArrayBase<T, Size>& other, plAllocator* pAllocator); // [tested]
  plSmallArrayBase(const plArrayPtr<const T>& other, plAllocator* pAllocator);       // [tested]
  plSmallArrayBase(plSmallArrayBase<T, Size>&& other, plAllocator* pAllocator);      // [tested]
 
  ~plSmallArrayBase();                                                               // [tested]
 
  // Can't use regular assignment operators since we need to pass an allocator. Use CopyFrom or MoveFrom methods instead.
  void operator=(const plSmallArrayBase<T, Size>& rhs) = delete;
  void operator=(plSmallArrayBase<T, Size>&& rhs) = delete;
 
  void CopyFrom(const plArrayPtr<const T>& other, plAllocator* pAllocator); // [tested]
 
  void MoveFrom(plSmallArrayBase<T, Size>&& other, plAllocator* pAllocator); // [tested]
 
  operator plArrayPtr<const T>() const; // [tested]
 
  operator plArrayPtr<T>(); // [tested]
 
  bool operator==(const plSmallArrayBase<T, Size>& rhs) const; // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plSmallArrayBase<T, Size>&);
 
#if PL_DISABLED(PL_USE_CPP20_OPERATORS)
  bool operator==(const plArrayPtr<const T>& rhs) const; // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plArrayPtr<const T>&);
#endif
  const T& operator[](plUInt32 uiIndex) const; // [tested]
 
  T& operator[](plUInt32 uiIndex); // [tested]
 
  void SetCount(plUInt16 uiCount, plAllocator* pAllocator); // [tested]
 
  void SetCount(plUInt16 uiCount, const T& fillValue, plAllocator* pAllocator); // [tested]
 
  template <typename = void>                                             // Template is used to only conditionally compile this function in when it is actually used.
  void SetCountUninitialized(plUInt16 uiCount, plAllocator* pAllocator); // [tested]
 
  void EnsureCount(plUInt16 uiCount, plAllocator* pAllocator); // [tested]
 
  plUInt32 GetCount() const; // [tested]
 
  bool IsEmpty() const; // [tested]
 
  void Clear(); // [tested]
 
  bool Contains(const T& value) const; // [tested]
 
  void Insert(const T& value, plUInt32 uiIndex, plAllocator* pAllocator); // [tested]
 
  void Insert(T&& value, plUInt32 uiIndex, plAllocator* pAllocator); // [tested]
 
  bool RemoveAndCopy(const T& value); // [tested]
 
  bool RemoveAndSwap(const T& value); // [tested]
 
  void RemoveAtAndCopy(plUInt32 uiIndex, plUInt16 uiNumElements = 1); // [tested]
 
  void RemoveAtAndSwap(plUInt32 uiIndex, plUInt16 uiNumElements = 1); // [tested]
 
  plUInt32 IndexOf(const T& value, plUInt32 uiStartIndex = 0) const; // [tested]
 
  plUInt32 LastIndexOf(const T& value, plUInt32 uiStartIndex = plSmallInvalidIndex) const; // [tested]
 
  T& ExpandAndGetRef(plAllocator* pAllocator); // [tested]
 
  void PushBack(const T& value, plAllocator* pAllocator); // [tested]
 
  void PushBack(T&& value, plAllocator* pAllocator); // [tested]
 
  void PushBackUnchecked(const T& value); // [tested]
 
  void PushBackUnchecked(T&& value); // [tested]
 
  void PushBackRange(const plArrayPtr<const T>& range, plAllocator* pAllocator); // [tested]
 
  void PopBack(plUInt32 uiCountToRemove = 1); // [tested]
 
  T& PeekBack(); // [tested]
 
  const T& PeekBack() const; // [tested]
 
  template <typename Comparer>
  void Sort(const Comparer& comparer); // [tested]
 
  void Sort(); // [tested]
 
  T* GetData();
 
  const T* GetData() const;
 
  plArrayPtr<T> GetArrayPtr(); // [tested]
 
  plArrayPtr<const T> GetArrayPtr() const; // [tested]
 
  plArrayPtr<typename plArrayPtr<T>::ByteType> GetByteArrayPtr(); // [tested]
 
  plArrayPtr<typename plArrayPtr<const T>::ByteType> GetByteArrayPtr() const; // [tested]
 
  void Reserve(plUInt16 uiCapacity, plAllocator* pAllocator); // [tested]
 
  void Compact(plAllocator* pAllocator); // [tested]
 
  plUInt32 GetCapacity() const { return m_uiCapacity; }
 
  plUInt64 GetHeapMemoryUsage() const; // [tested]
 
  using value_type = T;
  using const_reference = const T&;
  using const_iterator = const T*;
  using const_reverse_iterator = const_reverse_pointer_iterator<T>;
  using iterator = T*;
  using reverse_iterator = reverse_pointer_iterator<T>;
 
  template <typename U>
  const U& GetUserData() const; // [tested]
 
  template <typename U>
  U& GetUserData();             // [tested]
 
protected:
  enum
  {
    CAPACITY_ALIGNMENT = 4
  };
 
  void SetCapacity(plUInt16 uiCapacity, plAllocator* pAllocator);
 
  T* GetElementsPtr();
  const T* GetElementsPtr() const;
 
  plUInt16 m_uiCount = 0;
  plUInt16 m_uiCapacity = Size;
 
  plUInt32 m_uiUserData = 0;
 
  union
  {
    struct alignas(PL_ALIGNMENT_OF(T))
    {
      plUInt8 m_StaticData[Size * sizeof(T)];
    };
 
    T* m_pElements = nullptr;
  };
};
 
 
template <typename T, plUInt16 Size, typename AllocatorWrapper = plDefaultAllocatorWrapper>
class plSmallArray : public plSmallArrayBase<T, Size>
{
  using SUPER = plSmallArrayBase<T, Size>;
 
public:
  // Only if the stored type is either POD or relocatable the hybrid array itself is also relocatable.
  PL_DECLARE_MEM_RELOCATABLE_TYPE_CONDITIONAL(T);
 
  plSmallArray();
 
  plSmallArray(const plSmallArray<T, Size, AllocatorWrapper>& other);
  plSmallArray(const plArrayPtr<const T>& other);
  plSmallArray(plSmallArray<T, Size, AllocatorWrapper>&& other);
 
  ~plSmallArray();
 
  void operator=(const plSmallArray<T, Size, AllocatorWrapper>& rhs);
  void operator=(const plArrayPtr<const T>& rhs);
  void operator=(plSmallArray<T, Size, AllocatorWrapper>&& rhs) noexcept;
 
  void SetCount(plUInt16 uiCount);                      // [tested]
  void SetCount(plUInt16 uiCount, const T& fillValue);  // [tested]
  void EnsureCount(plUInt16 uiCount);                   // [tested]
 
  template <typename = void>
  void SetCountUninitialized(plUInt16 uiCount);         // [tested]
 
  void InsertAt(plUInt32 uiIndex, const T& value);      // [tested]
  void InsertAt(plUInt32 uiIndex, T&& value);           // [tested]
 
  T& ExpandAndGetRef();                                 // [tested]
  void PushBack(const T& value);                        // [tested]
  void PushBack(T&& value);                             // [tested]
  void PushBackRange(const plArrayPtr<const T>& range); // [tested]
 
  void Reserve(plUInt16 uiCapacity);
  void Compact();
};
 
#include <Foundation/Containers/Implementation/SmallArray_inl.h>