TPointerVector.h

Go to the documentation of this file.

/********************************************************************************
**  This file is part of the ICF Framework. Copyright (C) Witold Gantzke & Kirill Lepskiy
**  ICF Framework may be used under the terms of the LGPL License v. 2.1 by the Free Software Foundation.
********************************************************************************/
 
#pragma once
 
 
// STL includes
#include <vector>
 
// ICF 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* release(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([[maybe_unused]] const TPointerVector& otherVector)
{
    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::release(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