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 */