ArrayBase.h

#pragma once
 
#include <Foundation/Algorithm/Sorting.h>
#include <Foundation/Math/Math.h>
#include <Foundation/Types/ArrayPtr.h>
 
#if PL_ENABLED(PL_INTEROP_STL_SPAN)
#  include <span>
#endif
 
#ifndef plInvalidIndex
#  define plInvalidIndex 0xFFFFFFFF
#endif
 
template <typename T, typename Derived>
class plArrayBase
{
public:
  plArrayBase(); // [tested]
 
  ~plArrayBase(); // [tested]
 
  void operator=(const plArrayPtr<const T>& rhs); // [tested]
 
  operator plArrayPtr<const T>() const; // [tested]
 
  operator plArrayPtr<T>(); // [tested]
 
  bool operator==(const plArrayBase<T, Derived>& rhs) const; // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plArrayBase<T, Derived>&);
 
  bool operator<(const plArrayBase<T, Derived>& rhs) const; // [tested]
 
#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
 
  bool operator<(const plArrayPtr<const T>& rhs) const; // [tested]
 
  const T& operator[](plUInt32 uiIndex) const; // [tested]
 
  T& operator[](plUInt32 uiIndex); // [tested]
 
  void SetCount(plUInt32 uiCount); // [tested]
 
  void SetCount(plUInt32 uiCount, const T& fillValue); // [tested]
 
  template <typename = void>                    // Template is used to only conditionally compile this function in when it is actually used.
  void SetCountUninitialized(plUInt32 uiCount); // [tested]
 
  void EnsureCount(plUInt32 uiCount); // [tested]
 
  plUInt32 GetCount() const; // [tested]
 
  bool IsEmpty() const; // [tested]
 
  void Clear(); // [tested]
 
  bool Contains(const T& value) const; // [tested]
 
  void InsertAt(plUInt32 uiIndex, const T& value); // [tested]
 
  void InsertAt(plUInt32 uiIndex, T&& value); // [tested]
 
  void InsertRange(const plArrayPtr<const T>& range, plUInt32 uiIndex); // [tested]
 
  bool RemoveAndCopy(const T& value); // [tested]
 
  bool RemoveAndSwap(const T& value); // [tested]
 
  void RemoveAtAndCopy(plUInt32 uiIndex, plUInt32 uiNumElements = 1); // [tested]
 
  void RemoveAtAndSwap(plUInt32 uiIndex, plUInt32 uiNumElements = 1); // [tested]
 
  plUInt32 IndexOf(const T& value, plUInt32 uiStartIndex = 0) const; // [tested]
 
  plUInt32 LastIndexOf(const T& value, plUInt32 uiStartIndex = plInvalidIndex) const; // [tested]
 
  T& ExpandAndGetRef(); // [tested]
 
  T* ExpandBy(plUInt32 uiNumNewItems);
 
  void PushBack(const T& value); // [tested]
 
  void PushBack(T&& value); // [tested]
 
  void PushBackUnchecked(const T& value); // [tested]
 
  void PushBackUnchecked(T&& value); // [tested]
 
  void PushBackRange(const plArrayPtr<const T>& range); // [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]
 
  plUInt32 GetCapacity() const { return m_uiCapacity; }
 
  using const_iterator = const T*;
  using const_reverse_iterator = const_reverse_pointer_iterator<T>;
  using iterator = T*;
  using reverse_iterator = reverse_pointer_iterator<T>;
 
#if PL_ENABLED(PL_INTEROP_STL_SPAN)
  operator std::span<const T>() const
  {
    return std::span(GetData(), static_cast<size_t>(GetCount()));
  }
 
  operator std::span<T>()
  {
    return std::span(GetData(), static_cast<size_t>(GetCount()));
  }
 
  std::span<T> GetSpan()
  {
    return std::span(GetData(), static_cast<size_t>(GetCount()));
  }
 
  std::span<const T> GetSpan() const
  {
    return std::span(GetData(), static_cast<size_t>(GetCount()));
  }
#endif
 
protected:
  void DoSwap(plArrayBase<T, Derived>& other);
 
  T* m_pElements = nullptr;
 
  plUInt32 m_uiCount = 0;
 
  plUInt32 m_uiCapacity = 0;
};
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::iterator begin(plArrayBase<T, Derived>& ref_container)
{
  return ref_container.GetData();
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::const_iterator begin(const plArrayBase<T, Derived>& container)
{
  return container.GetData();
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::const_iterator cbegin(const plArrayBase<T, Derived>& container)
{
  return container.GetData();
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::reverse_iterator rbegin(plArrayBase<T, Derived>& ref_container)
{
  return typename plArrayBase<T, Derived>::reverse_iterator(ref_container.GetData() + ref_container.GetCount() - 1);
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::const_reverse_iterator rbegin(const plArrayBase<T, Derived>& container)
{
  return typename plArrayBase<T, Derived>::const_reverse_iterator(container.GetData() + container.GetCount() - 1);
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::const_reverse_iterator crbegin(const plArrayBase<T, Derived>& container)
{
  return typename plArrayBase<T, Derived>::const_reverse_iterator(container.GetData() + container.GetCount() - 1);
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::iterator end(plArrayBase<T, Derived>& ref_container)
{
  return ref_container.GetData() + ref_container.GetCount();
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::const_iterator end(const plArrayBase<T, Derived>& container)
{
  return container.GetData() + container.GetCount();
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::const_iterator cend(const plArrayBase<T, Derived>& container)
{
  return container.GetData() + container.GetCount();
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::reverse_iterator rend(plArrayBase<T, Derived>& ref_container)
{
  return typename plArrayBase<T, Derived>::reverse_iterator(ref_container.GetData() - 1);
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::const_reverse_iterator rend(const plArrayBase<T, Derived>& container)
{
  return typename plArrayBase<T, Derived>::const_reverse_iterator(container.GetData() - 1);
}
 
template <typename T, typename Derived>
typename plArrayBase<T, Derived>::const_reverse_iterator crend(const plArrayBase<T, Derived>& container)
{
  return typename plArrayBase<T, Derived>::const_reverse_iterator(container.GetData() - 1);
}
 
#include <Foundation/Containers/Implementation/ArrayBase_inl.h>