PointerVector.h

Go to the documentation of this file.

#ifndef PCAPPP_POINTER_VECTOR
#define PCAPPP_POINTER_VECTOR
 
#include <stdio.h>
#include <stdint.h>
#include <vector>
 
 
namespace pcpp
{
 
    template<typename T>
    class PointerVector
    {
    public:
        typedef typename std::vector<T*>::iterator VectorIterator;
 
        typedef typename std::vector<T*>::const_iterator ConstVectorIterator;
 
        PointerVector() { }
 
        ~PointerVector()
        {
            for (VectorIterator iter = m_Vector.begin(); iter != m_Vector.end(); iter++)
            {
                delete (*iter);
            }
        }
 
        PointerVector(const PointerVector& other)
        {
            for (ConstVectorIterator iter = other.begin(); iter != other.end(); iter++)
            {
                T* objCopy = new T(**iter);
                m_Vector.push_back(objCopy);
            }
        }
 
        void clear()
        {
            for (VectorIterator iter = m_Vector.begin(); iter != m_Vector.end(); iter++)
            {
                delete (*iter);
            }
 
            m_Vector.clear();
        }
 
        void pushBack(T* element) { m_Vector.push_back(element); }
 
        VectorIterator begin() { return m_Vector.begin(); }
 
        ConstVectorIterator begin() const { return m_Vector.begin(); }
 
        VectorIterator end() { return m_Vector.end(); }
 
        ConstVectorIterator end() const { return m_Vector.end(); }
 
 
        //inline size_t size() { return m_Vector.size(); }
 
        size_t size() const { return m_Vector.size(); }
 
        T* front() { return m_Vector.front(); }
 
        VectorIterator erase(VectorIterator position)
        {
            delete (*position);
            return m_Vector.erase(position);
        }
 
        T* getAndRemoveFromVector(VectorIterator& position)
        {
            T* result = (*position);
            VectorIterator tempPos = position;
            tempPos = m_Vector.erase(tempPos);
            position = tempPos;
            return result;
        }
 
        T* at(int index)
        {
            return m_Vector.at(index);
        }
 
        const T* at(int index) const
        {
            return m_Vector.at(index);
        }
 
    private:
        std::vector<T*> m_Vector;
    };
 
} // namespace pcpp
 
#endif /* PCAPPP_POINTER_VECTOR */