TPointerVector.h

Go to the documentation of this file.

// SPDX-License-Identifier: LGPL-2.1-or-later OR GPL-2.0-or-later OR GPL-3.0-or-later OR LicenseRef-ACF-Commercial
#pragma once
 
 
// STL includes
#include <vector>
 
// ACF includes
#include <istd/istd.h>
 
 
namespace istd
{
 
 
template<typename Pointer>
class TDeleteAdapter
{
public:
       typedef Pointer* ElementType;
 
       static Pointer* GetPtr(const ElementType& element)
       {
              return element;
       }
 
       static Pointer* PopPtr(const ElementType& element)
       {
              return GetPtr(element);
       }
 
       static void Delete(const ElementType& element)
       {
              delete element;
       }
};
 
 
template <typename Pointer, class AccessAdapter = TDeleteAdapter<Pointer> >
class TPointerVector
{
public:
       typedef typename AccessAdapter::ElementType ElementType;
 
       enum
       {
              InvalidIndex = -1
       };
 
       TPointerVector();
       TPointerVector(const TPointerVector&);
 
       ~TPointerVector();
 
       bool IsEmpty() const;
 
       int GetCount() const;
 
       void SetCount(int count);
 
       void Reset();
 
       int HasElement(const Pointer* elementPtr) const;
 
       Pointer* GetAt(int index) const;
 
       const ElementType& GetElementAt(int index) const;
 
       void SetElementAt(int index, const ElementType& element);
 
       void RemoveAt(int index);
 
       bool Remove(Pointer* elementPtr);
 
       Pointer* PopAt(int index);
 
       void PushBack(const ElementType& element);
 
       void InsertElementAt(int index, const ElementType& element);
 
       void SwapElements(int index1, int index2);
 
private:
       typedef std::vector<ElementType> Elements;
 
       Elements m_elements;
};
 
 
// inline methods
 
template <typename Pointer, class AccessAdapter>
inline TPointerVector<Pointer, AccessAdapter>::TPointerVector()
{
}
 
 
template <typename Pointer, class AccessAdapter>
inline TPointerVector<Pointer, AccessAdapter>::TPointerVector(const TPointerVector& I_IF_DEBUG(otherVector))
{
       I_IF_DEBUG(Q_ASSERT(otherVector.IsEmpty()));
}
 
 
template <typename Pointer, class AccessAdapter>
inline bool TPointerVector<Pointer, AccessAdapter>::IsEmpty() const
{
       return m_elements.empty();
}
 
 
template <typename Pointer, class AccessAdapter>
inline int TPointerVector<Pointer, AccessAdapter>::GetCount() const
{
       return int(m_elements.size());
}
 
 
// public methods
 
template <typename Pointer, class AccessAdapter>
TPointerVector<Pointer, AccessAdapter>::~TPointerVector()
{
       Reset();
}
 
 
template <typename Pointer, class AccessAdapter>
void TPointerVector<Pointer, AccessAdapter>::SetCount(int count)
{
       while (int(m_elements.size()) > count){
              AccessAdapter::Delete(m_elements.back());
 
              m_elements.pop_back();
       }
 
       m_elements.resize(count);
}
 
 
template <typename Pointer, class AccessAdapter>
void TPointerVector<Pointer, AccessAdapter>::Reset()
{
       for (         typename Elements::iterator iter = m_elements.begin();
                            iter != m_elements.end();
                            ++iter){
              AccessAdapter::Delete(*iter);
       }
 
       m_elements.clear();
}
 
 
template <typename Pointer, class AccessAdapter>
int TPointerVector<Pointer, AccessAdapter>::HasElement(const Pointer* elementPtr) const
{
       int elementsCount = GetCount();
 
       for (int elementIndex = 0; elementIndex < elementsCount; elementIndex++){
              typename Elements::const_iterator delIter = (m_elements.begin() + elementIndex);
              if (AccessAdapter::GetPtr(*delIter) == elementPtr){
                     return elementIndex;
              }
       }
 
       return InvalidIndex;
}
 
 
template <typename Pointer, class AccessAdapter>
Pointer* TPointerVector<Pointer, AccessAdapter>::GetAt(int index) const
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < int(m_elements.size()));
 
       return AccessAdapter::GetPtr(m_elements[index]);
}
 
 
template <typename Pointer, class AccessAdapter>
const typename TPointerVector<Pointer, AccessAdapter>::ElementType& TPointerVector<Pointer, AccessAdapter>::GetElementAt(int index) const
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < int(m_elements.size()));
 
       return m_elements[index];
}
 
 
template <typename Pointer, class AccessAdapter>
void TPointerVector<Pointer, AccessAdapter>::SetElementAt(int index, const ElementType& element)
{
       typename Elements::iterator delIter = (m_elements.begin() + index);
 
       AccessAdapter::Delete(*delIter);
 
       m_elements[index] = element;
}
 
 
template <typename Pointer, class AccessAdapter>
void TPointerVector<Pointer, AccessAdapter>::RemoveAt(int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < int(m_elements.size()));
 
       typename Elements::iterator delIter = (m_elements.begin() + index);
 
       AccessAdapter::Delete(*delIter);
 
       m_elements.erase(delIter);
}
 
       
template <typename Pointer, class AccessAdapter>
bool TPointerVector<Pointer, AccessAdapter>::Remove(Pointer* elementPtr)
{
       int elementsCount = GetCount();
 
       for (int elementIndex = 0; elementIndex < elementsCount; elementIndex++){
              typename Elements::iterator delIter = (m_elements.begin() + elementIndex);
              if (AccessAdapter::GetPtr(*delIter) == elementPtr){
                     RemoveAt(elementIndex);
 
                     return true;
              }
       }
 
       return false;
}
 
 
template <typename Pointer, class AccessAdapter>
Pointer* TPointerVector<Pointer, AccessAdapter>::PopAt(int index)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index < int(m_elements.size()));
 
       Pointer* popPtr = AccessAdapter::PopPtr(m_elements[index]);
 
       m_elements.erase(m_elements.begin() + index);
 
       return popPtr;
}
 
 
template <typename Pointer, class AccessAdapter>
void TPointerVector<Pointer, AccessAdapter>::PushBack(const ElementType& element)
{
       m_elements.push_back(element);
}
 
 
template <typename Pointer, class AccessAdapter>
void TPointerVector<Pointer, AccessAdapter>::InsertElementAt(int index, const ElementType& element)
{
       Q_ASSERT(index >= 0);
       Q_ASSERT(index <= GetCount());
       Q_ASSERT(HasElement(AccessAdapter::GetPtr(element)) == InvalidIndex);
 
       m_elements.insert(m_elements.begin() + index, element);
}
 
 
template <typename Pointer, class AccessAdapter>
void TPointerVector<Pointer, AccessAdapter>::SwapElements(int index1, int index2)
{
       Q_ASSERT(index1 >= 0);
       Q_ASSERT(index1 <= GetCount());
       Q_ASSERT(index2 >= 0);
       Q_ASSERT(index2 <= GetCount());
 
       ElementType element1 = m_elements[index1];
       m_elements[index1] = m_elements[index2];
       m_elements[index2] = element1;
}
 
 
} // namespace istd