/src/PcapPlusPlus/Common++/header/PointerVector.h

Source (jump to first uncovered line)
#pragma once

#include <stdio.h>
#include <stdint.h>
#include <vector>

/// @file

/**
 * \namespace pcpp
 * \brief The main namespace for the PcapPlusPlus lib
 */
namespace pcpp
{

  /**
   * @class PointerVector
   * A template class for representing a std::vector of pointers. Once (a pointer to) an element is added to this vector,
   * the element responsibility moves to the vector, meaning the PointerVector will free the object once it's removed from the vector
   * This class wraps std::vector and adds the capability of freeing objects once they're removed from it
   */
  template<typename T>
  class PointerVector
  {
  public:
    /**
     * Iterator object that is used for iterating all elements in the vector
     */
    typedef typename std::vector<T*>::iterator VectorIterator;

    /**
     * Const iterator object that is used for iterating all elements in a constant vector
     */
    typedef typename std::vector<T*>::const_iterator ConstVectorIterator;

    /**
     * A constructor that create an empty instance of this object
     */
    PointerVector() { }

    /**
     * A destructor for this class. The destructor frees all elements that are binded to the vector
     */
    ~PointerVector()
    {
      for (auto iter : m_Vector)
      {
        delete iter;
      }
    }

    /**
     * Copy constructor. Once a vector is copied from another vector, all elements inside it are copied,
     * meaning the new vector will contain pointers to copied elements, not pointers to the elements of the original vector
     */
    PointerVector(const PointerVector& other)
    {
      for (const auto iter : other)
      {
        T* objCopy = new T(*iter);
        m_Vector.push_back(objCopy);
      }
    }

    /**
     * Clears all elements of the vector while freeing them
     */
    void clear()
    {
      for (auto iter : m_Vector)
      {
        delete iter;
      }

      m_Vector.clear();
    }

    /**
     * Add a new (pointer to an) element to the vector
     */
    void pushBack(T* element) { m_Vector.push_back(element); }

    /**
     * Get the first element of the vector
     * @return An iterator object pointing to the first element of the vector
     */
    VectorIterator begin() { return m_Vector.begin(); }

    /**
     * Get the first element of a constant vector
     * @return A const iterator object pointing to the first element of the vector
     */
    ConstVectorIterator begin() const { return m_Vector.begin(); }

    /**
     * Get the last element of the vector
     * @return An iterator object pointing to the last element of the vector
     */
    VectorIterator end() { return m_Vector.end(); }

    /**
     * Get the last element of a constant vector
     * @return A const iterator object pointing to the last element of the vector
     */
    ConstVectorIterator end() const { return m_Vector.end(); }


    //inline size_t size() { return m_Vector.size(); }

    /**
     * Get number of elements in the vector
     * @return The number of elements in the vector
     */
    size_t size() const { return m_Vector.size(); }

    /**
     * Returns a pointer of the first element in the vector
     * @return A pointer of the first element in the vector
     */
    T* front() { return m_Vector.front(); }

    /**
     * Removes from the vector a single element (position). Once the element is erased, it's also freed
     * @param[in] position The position of the element to erase
     * @return An iterator pointing to the new location of the element that followed the last element erased by the function call
     */
    VectorIterator erase(VectorIterator position)
    {
      delete (*position);
      return m_Vector.erase(position);
    }

    /**
     * Remove an element from the vector without freeing it
     * param[in] position The position of the element to remove from the vector
     * @return A pointer to the element which is no longer managed by the vector. It's user responsibility to free it
     */
    T* getAndRemoveFromVector(VectorIterator& position)
    {
      T* result = (*position);
      VectorIterator tempPos = position;
      tempPos = m_Vector.erase(tempPos);
      position = tempPos;
      return result;
    }

    /**
     * Return a pointer to the element in a certain index
     * @param[in] index The index to retrieve the element from
     * @return The element at the specified position in the vector
     */
    T* at(int index)
    {
      return m_Vector.at(index);
    }

    /**
     * Return a const pointer to the element in a certain index
     * @param[in] index The index to retrieve the element from
     * @return The element at the specified position in the vector
     */
    const T* at(int index) const
    {
      return m_Vector.at(index);
    }

  private:
    std::vector<T*> m_Vector;
  };

} // namespace pcpp

Coverage Report

Created: 2024-02-25 06:29