IdTable.h

#pragma once
 
#include <Foundation/Memory/AllocatorWrapper.h>
#include <Foundation/Types/Id.h>
 
template <typename IdType, typename ValueType>
class plIdTableBase
{
public:
  using IndexType = typename IdType::StorageType;
  using TypeOfId = IdType;
 
  class ConstIterator
  {
  public:
    bool IsValid() const; // [tested]
 
    bool operator==(const typename plIdTableBase<IdType, ValueType>::ConstIterator& it2) const;
 
    bool operator!=(const typename plIdTableBase<IdType, ValueType>::ConstIterator& it2) const;
 
    IdType Id() const; // [tested]
 
    const ValueType& Value() const; // [tested]
 
    void Next(); // [tested]
 
    void operator++(); // [tested]
 
  protected:
    friend class plIdTableBase<IdType, ValueType>;
 
    explicit ConstIterator(const plIdTableBase<IdType, ValueType>& idTable);
 
    const plIdTableBase<IdType, ValueType>& m_IdTable;
    IndexType m_CurrentIndex; // current element index that this iterator points to.
    IndexType m_CurrentCount; // current number of valid elements that this iterator has found so far.
  };
 
  struct Iterator : public ConstIterator
  {
  public:
    // this is required to pull in the const version of this function
    using ConstIterator::Value;
 
    ValueType& Value(); // [tested]
 
  private:
    friend class plIdTableBase<IdType, ValueType>;
 
    explicit Iterator(const plIdTableBase<IdType, ValueType>& idTable);
  };
 
protected:
  explicit plIdTableBase(plAllocator* pAllocator); // [tested]
 
  plIdTableBase(const plIdTableBase<IdType, ValueType>& rhs, plAllocator* pAllocator); // [tested]
 
  ~plIdTableBase(); // [tested]
 
  void operator=(const plIdTableBase<IdType, ValueType>& rhs); // [tested]
 
public:
  void Reserve(IndexType capacity); // [tested]
 
  IndexType GetCount() const; // [tested]
 
  bool IsEmpty() const; // [tested]
 
  void Clear(); // [tested]
 
  IdType Insert(const ValueType& value); // [tested]
 
  IdType Insert(ValueType&& value);
 
  bool Remove(const IdType id, ValueType* out_pOldValue = nullptr); // [tested]
 
  bool TryGetValue(const IdType id, ValueType& out_value) const; // [tested]
 
  bool TryGetValue(const IdType id, ValueType*& out_pValue) const; // [tested]
 
  const ValueType& operator[](const IdType id) const; // [tested]
 
  ValueType& operator[](const IdType id); // [tested]
 
  const ValueType& GetValueUnchecked(const IndexType index) const;
 
  ValueType& GetValueUnchecked(const IndexType index);
 
  bool Contains(const IdType id) const; // [tested]
 
  Iterator GetIterator(); // [tested]
 
  ConstIterator GetIterator() const; // [tested]
 
  plAllocator* GetAllocator() const;
 
  bool IsFreelistValid() const;
 
private:
  enum
  {
    CAPACITY_ALIGNMENT = 16
  };
 
  struct Entry
  {
    IdType id;
    ValueType value;
  };
 
  Entry* m_pEntries;
 
  IndexType m_Count;
  IndexType m_Capacity;
 
  IndexType m_FreelistEnqueue;
  IndexType m_FreelistDequeue;
 
  plAllocator* m_pAllocator;
 
  void SetCapacity(IndexType uiCapacity);
  void InitializeFreelist(IndexType uiStart, IndexType uiEnd);
};
 
template <typename IdType, typename ValueType, typename AllocatorWrapper = plDefaultAllocatorWrapper>
class plIdTable : public plIdTableBase<IdType, ValueType>
{
public:
  plIdTable();
  explicit plIdTable(plAllocator* pAllocator);
 
  plIdTable(const plIdTable<IdType, ValueType, AllocatorWrapper>& other);
  plIdTable(const plIdTableBase<IdType, ValueType>& other);
 
  void operator=(const plIdTable<IdType, ValueType, AllocatorWrapper>& rhs);
  void operator=(const plIdTableBase<IdType, ValueType>& rhs);
};
 
#include <Foundation/Containers/Implementation/IdTable_inl.h>