ArrayMap.h

#pragma once
 
#include <Foundation/Containers/DynamicArray.h>
 
template <typename KEY, typename VALUE>
class plArrayMapBase
{
 
public:
  struct Pair
  {
    KEY key;
    VALUE value;
 
    PL_DETECT_TYPE_CLASS(KEY, VALUE);
 
    PL_ALWAYS_INLINE bool operator<(const Pair& rhs) const { return key < rhs.key; }
 
    PL_ALWAYS_INLINE bool operator==(const Pair& rhs) const { return key == rhs.key; }
  };
 
  explicit plArrayMapBase(plAllocator* pAllocator); // [tested]
 
  plArrayMapBase(const plArrayMapBase& rhs, plAllocator* pAllocator); // [tested]
 
  void operator=(const plArrayMapBase& rhs); // [tested]
 
  plUInt32 GetCount() const; // [tested]
 
  bool IsEmpty() const; // [tested]
 
  void Clear(); // [tested]
 
  template <typename CompatibleKeyType, typename CompatibleValueType>
  plUInt32 Insert(CompatibleKeyType&& key, CompatibleValueType&& value); // [tested]
 
  void Sort() const; // [tested]
 
  template <typename CompatibleKeyType>
  plUInt32 Find(const CompatibleKeyType& key) const; // [tested]
 
  template <typename CompatibleKeyType>
  plUInt32 LowerBound(const CompatibleKeyType& key) const; // [tested]
 
  template <typename CompatibleKeyType>
  plUInt32 UpperBound(const CompatibleKeyType& key) const; // [tested]
 
  const KEY& GetKey(plUInt32 uiIndex) const; // [tested]
 
  const VALUE& GetValue(plUInt32 uiIndex) const; // [tested]
 
  VALUE& GetValue(plUInt32 uiIndex); // [tested]
 
  plDynamicArray<Pair>& GetData();
 
  const plDynamicArray<Pair>& GetData() const;
 
  template <typename CompatibleKeyType>
  VALUE& FindOrAdd(const CompatibleKeyType& key, bool* out_pExisted = nullptr); // [tested]
 
  template <typename CompatibleKeyType>
  VALUE& operator[](const CompatibleKeyType& key); // [tested]
 
  const Pair& GetPair(plUInt32 uiIndex) const; // [tested]
 
  void RemoveAtAndCopy(plUInt32 uiIndex, bool bKeepSorted = false);
 
  template <typename CompatibleKeyType>
  bool RemoveAndCopy(const CompatibleKeyType& key, bool bKeepSorted = false); // [tested]
 
  template <typename CompatibleKeyType>
  bool Contains(const CompatibleKeyType& key) const; // [tested]
 
  template <typename CompatibleKeyType>
  bool Contains(const CompatibleKeyType& key, const VALUE& value) const; // [tested]
 
  void Reserve(plUInt32 uiSize); // [tested]
 
  void Compact(); // [tested]
 
  bool operator==(const plArrayMapBase<KEY, VALUE>& rhs) const; // [tested]
  PL_ADD_DEFAULT_OPERATOR_NOTEQUAL(const plArrayMapBase<KEY, VALUE>&);
 
  plUInt64 GetHeapMemoryUsage() const { return m_Data.GetHeapMemoryUsage(); } // [tested]
 
  using const_iterator = typename plDynamicArray<Pair>::const_iterator;
  using const_reverse_iterator = typename plDynamicArray<Pair>::const_reverse_iterator;
  using iterator = typename plDynamicArray<Pair>::iterator;
  using reverse_iterator = typename plDynamicArray<Pair>::reverse_iterator;
 
private:
  mutable bool m_bSorted;
  mutable plDynamicArray<Pair> m_Data;
};
 
template <typename KEY, typename VALUE, typename AllocatorWrapper = plDefaultAllocatorWrapper>
class plArrayMap : public plArrayMapBase<KEY, VALUE>
{
  PL_DECLARE_MEM_RELOCATABLE_TYPE();
 
public:
  plArrayMap();
  explicit plArrayMap(plAllocator* pAllocator);
 
  plArrayMap(const plArrayMap<KEY, VALUE, AllocatorWrapper>& rhs);
  plArrayMap(const plArrayMapBase<KEY, VALUE>& rhs);
 
  void operator=(const plArrayMap<KEY, VALUE, AllocatorWrapper>& rhs);
  void operator=(const plArrayMapBase<KEY, VALUE>& rhs);
};
 
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::iterator begin(plArrayMapBase<KEY, VALUE>& ref_container)
{
  return begin(ref_container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::const_iterator begin(const plArrayMapBase<KEY, VALUE>& container)
{
  return begin(container.GetData());
}
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::const_iterator cbegin(const plArrayMapBase<KEY, VALUE>& container)
{
  return cbegin(container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::reverse_iterator rbegin(plArrayMapBase<KEY, VALUE>& ref_container)
{
  return rbegin(ref_container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::const_reverse_iterator rbegin(const plArrayMapBase<KEY, VALUE>& container)
{
  return rbegin(container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::const_reverse_iterator crbegin(const plArrayMapBase<KEY, VALUE>& container)
{
  return crbegin(container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::iterator end(plArrayMapBase<KEY, VALUE>& ref_container)
{
  return end(ref_container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::const_iterator end(const plArrayMapBase<KEY, VALUE>& container)
{
  return end(container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::const_iterator cend(const plArrayMapBase<KEY, VALUE>& container)
{
  return cend(container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::reverse_iterator rend(plArrayMapBase<KEY, VALUE>& ref_container)
{
  return rend(ref_container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::const_reverse_iterator rend(const plArrayMapBase<KEY, VALUE>& container)
{
  return rend(container.GetData());
}
 
template <typename KEY, typename VALUE>
typename plArrayMapBase<KEY, VALUE>::const_reverse_iterator crend(const plArrayMapBase<KEY, VALUE>& container)
{
  return crend(container.GetData());
}
 
 
#include <Foundation/Containers/Implementation/ArrayMap_inl.h>