List.h

#pragma once
 
#include <Foundation/Containers/Deque.h>
 
template <typename T>
class plListBase
{
private:
  struct ListElement;
 
  struct ListElementBase
  {
    ListElementBase();
 
    ListElement* m_pPrev;
    ListElement* m_pNext;
  };
 
  struct ListElement : public ListElementBase
  {
    ListElement()
      : ListElementBase()
    {
    }
    explicit ListElement(const T& data);
 
    T m_Data = {};
  };
 
  struct ConstIterator
  {
    PL_DECLARE_POD_TYPE();
 
    ConstIterator()
      : m_pElement(nullptr)
    {
    } // [tested]
 
    bool operator==(typename plListBase<T>::ConstIterator it2) const { return (m_pElement == it2.m_pElement); } // [tested]
    PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(typename plListBase<T>::ConstIterator);
 
    const T& operator*() const { return (m_pElement->m_Data); } // [tested]
 
    const T* operator->() const { return (&m_pElement->m_Data); } // [tested]
 
    void Next() { m_pElement = m_pElement->m_pNext; } // [tested]
 
    void Prev() { m_pElement = m_pElement->m_pPrev; } // [tested]
 
    bool IsValid() const { return ((m_pElement != nullptr) && (m_pElement->m_pPrev != nullptr) && (m_pElement->m_pNext != nullptr)); } // [tested]
 
    void operator++() { Next(); } // [tested]
 
    void operator--() { Prev(); } // [tested]
 
  private:
    friend class plListBase<T>;
 
    ConstIterator(ListElement* pInit)
      : m_pElement(pInit)
    {
    }
 
    ListElement* m_pElement;
  };
 
public:
  struct Iterator : public ConstIterator
  {
    // this is required to pull in the const version of this function
    using ConstIterator::operator*;
    using ConstIterator::operator->;
 
    PL_DECLARE_POD_TYPE();
 
    Iterator()
      : ConstIterator()
    {
    } // [tested]
 
    T& operator*() { return (this->m_pElement->m_Data); } // [tested]
 
    T* operator->() { return (&this->m_pElement->m_Data); } // [tested]
 
  private:
    friend class plListBase<T>;
 
    explicit Iterator(ListElement* pInit)
      : ConstIterator(pInit)
    {
    }
  };
 
protected:
  explicit plListBase(plAllocator* pAllocator); // [tested]
 
  plListBase(const plListBase<T>& cc, plAllocator* pAllocator); // [tested]
 
  ~plListBase(); // [tested]
 
  void operator=(const plListBase<T>& cc); // [tested]
 
public:
  void Clear(); // [tested]
 
  void Compact();
 
  plUInt32 GetCount() const; // [tested]
 
  bool IsEmpty() const; // [tested]
 
  const T& PeekFront() const; // [tested]
 
  const T& PeekBack() const; // [tested]
 
  T& PeekFront(); // [tested]
 
  T& PeekBack(); // [tested]
 
  T& PushBack(); // [tested]
 
  void PushBack(const T& element); // [tested]
 
  void PopBack(); // [tested]
 
  T& PushFront(); // [tested]
 
  void PushFront(const T& element); // [tested]
 
  void PopFront(); // [tested]
 
  void SetCount(plUInt32 uiNewSize); // [tested]
 
  Iterator Insert(const Iterator& pos, const T& data); // [tested]
 
  void Insert(const Iterator& pos, ConstIterator first, const ConstIterator& last);
 
  Iterator Insert(const Iterator& pos);
 
  Iterator Remove(const Iterator& pos); // [tested]
 
  Iterator Remove(Iterator first, const Iterator& last);
 
  Iterator GetIterator(); // [tested]
 
  Iterator GetEndIterator(); // [tested]
 
  ConstIterator GetIterator() const; // [tested]
 
  ConstIterator GetEndIterator() const; // [tested]
 
  plAllocator* GetAllocator() const { return m_Elements.GetAllocator(); }
 
  bool operator==(const plListBase<T>& rhs) const; // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plListBase<T>&);
 
  plUInt64 GetHeapMemoryUsage() const { return m_Elements.GetHeapMemoryUsage(); } // [tested]
 
private:
  ListElementBase m_First;
 
  ListElementBase m_Last;
 
  // \brief Small hack to get around const problems.
  Iterator m_End;
 
  plUInt32 m_uiCount;
 
  ListElement* AcquireNode();
 
  void ReleaseNode(ListElement* pNode);
 
  plDeque<ListElement, plNullAllocatorWrapper, false> m_Elements;
 
  ListElement* m_pFreeElementStack;
};
 
template <typename T, typename AllocatorWrapper = plDefaultAllocatorWrapper>
class plList : public plListBase<T>
{
public:
  plList();
  explicit plList(plAllocator* pAllocator);
 
  plList(const plList<T, AllocatorWrapper>& other);
  plList(const plListBase<T>& other);
 
  void operator=(const plList<T, AllocatorWrapper>& rhs);
  void operator=(const plListBase<T>& rhs);
};
 
#include <Foundation/Containers/Implementation/List_inl.h>