PointerVector.h

Go to the documentation of this file.

#pragma once
 
#include <cstddef>
#include <cstdio>
#include <cstdint>
#include <stdexcept>
#include <vector>
#include <memory>
#include <type_traits>
 
#include "DeprecationUtils.h"
 
 
namespace pcpp
{
    namespace internal
    {
        template <class T, class Enable = void> struct Copier
        {
            std::unique_ptr<T> operator()(const T& obj) const
            {
                return std::unique_ptr<T>(new T(obj));
            }
        };
 
        template <class T> struct Copier<T, typename std::enable_if<std::is_polymorphic<T>::value>::type>
        {
            std::unique_ptr<T> operator()(const T& obj) const
            {
                // Clone can return unique_ptr or raw pointer.
                return std::unique_ptr<T>(std::move(obj.clone()));
            }
        };
    }  // namespace internal
 
    template <typename T, typename Deleter = std::default_delete<T>> class PointerVector
    {
    public:
        using VectorIterator = typename std::vector<T*>::iterator;
 
        using ConstVectorIterator = typename std::vector<T*>::const_iterator;
 
        PointerVector() = default;
 
        PointerVector(const PointerVector& other) : m_Vector(deepCopyUnsafe(other.m_Vector))
        {}
 
        PointerVector(PointerVector&& other) noexcept : m_Vector(std::move(other.m_Vector))
        {
            other.m_Vector.clear();
        }
 
        ~PointerVector()
        {
            freeVectorUnsafe(m_Vector);
        }
 
        PointerVector& operator=(const PointerVector& other)
        {
            // Self-assignment check.
            if (this == &other)
            {
                return *this;
            }
 
            // Saves a copy of the old pointer to defer cleanup.
            auto oldValues = m_Vector;
            try
            {
                m_Vector = deepCopyUnsafe(other.m_Vector);
            }
            // If an exception is thrown during the copy operation, restore old values and rethrow.
            catch (const std::exception&)
            {
                m_Vector = std::move(oldValues);
                throw;
            }
            // Free old values as the new ones have been successfully assigned.
            freeVectorUnsafe(oldValues);
            return *this;
        }
 
        PointerVector& operator=(PointerVector&& other) noexcept
        {
            if (this == &other)
            {
                return *this;
            }
 
            // Releases all current elements.
            clear();
            // Moves the elements of the other vector.
            m_Vector = std::move(other.m_Vector);
            // Explicitly clear the other vector as the standard only guarantees an unspecified valid state after move.
            other.m_Vector.clear();
            return *this;
        }
 
        void clear()
        {
            freeVectorUnsafe(m_Vector);
            m_Vector.clear();
        }
 
        void pushBack(std::nullptr_t element, bool freeElementOnError = true) = delete;
 
        void pushBack(T* element, bool freeElementOnError = true)
        {
            if (element == nullptr)
            {
                throw std::invalid_argument("Element is nullptr");
            }
 
            try
            {
                m_Vector.push_back(element);
            }
            catch (const std::exception&)
            {
                if (freeElementOnError)
                {
                    Deleter{}(element);
                }
                throw;
            }
        }
 
        void pushBack(std::unique_ptr<T> element)
        {
            if (!element)
            {
                throw std::invalid_argument("Element is nullptr");
            }
 
            // Release is called after the raw pointer is already inserted into the vector to prevent
            // a memory leak if push_back throws.
            // cppcheck-suppress danglingLifetime
            m_Vector.push_back(element.get());
            element.release();
        }
 
        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();
        }
 
        size_t size() const
        {
            return m_Vector.size();
        }
 
        size_t capacity() const
        {
            return m_Vector.capacity();
        }
 
        void reserve(size_t size)
        {
            m_Vector.reserve(size);
        }
 
        T* front() const
        {
            return m_Vector.front();
        }
 
        T* back() const
        {
            return m_Vector.back();
        }
 
        VectorIterator erase(VectorIterator position)
        {
            Deleter{}(*position);
            return m_Vector.erase(position);
        }
 
        VectorIterator erase(ConstVectorIterator first, ConstVectorIterator last)
        {
            for (auto iter = first; iter != last; ++iter)
            {
                Deleter{}(*iter);
            }
            return m_Vector.erase(first, last);
        }
 
        PCPP_DEPRECATED("Please use the memory safe 'getAndDetach' instead.")
        T* getAndRemoveFromVector(VectorIterator& position)
        {
            T* result = *position;
            position = m_Vector.erase(position);
            return result;
        }
 
        std::unique_ptr<T> getAndDetach(size_t index)
        {
            return getAndDetach(m_Vector.begin() + index);
        }
 
        std::unique_ptr<T> getAndDetach(VectorIterator& position)
        {
            std::unique_ptr<T> result(*position);
            position = m_Vector.erase(position);
            return result;
        }
 
        std::unique_ptr<T> getAndDetach(const VectorIterator& position)
        {
            std::unique_ptr<T> result(*position);
            m_Vector.erase(position);
            return result;
        }
 
        T* at(int index) const
        {
            return m_Vector.at(index);
        }
 
    private:
        static std::vector<T*> deepCopyUnsafe(const std::vector<T*>& origin)
        {
            std::vector<T*> copyVec;
            // Allocate the vector initially to ensure no exceptions are thrown during push_back.
            copyVec.reserve(origin.size());
 
            try
            {
                for (const auto iter : origin)
                {
                    std::unique_ptr<T> objCopy = internal::Copier<T>()(*iter);
                    // There shouldn't be a memory leak as the vector is reserved.
                    copyVec.push_back(objCopy.release());
                }
            }
            catch (const std::exception&)
            {
                freeVectorUnsafe(copyVec);
                throw;
            }
 
            return copyVec;
        }
 
        static void freeVectorUnsafe(const std::vector<T*>& origin)
        {
            for (auto& obj : origin)
            {
                Deleter{}(obj);
            }
        }
 
        std::vector<T*> m_Vector;
    };
 
}  // namespace pcpp