DeviceListBase.h

#pragma once
#include "PointerVector.h"
 
namespace pcpp
{
    namespace internal
    {
        template <typename T, typename Deleter = std::default_delete<T>> class DeviceListBase
        {
        protected:
            DeviceListBase() = default;
 
            explicit DeviceListBase(PointerVector<T, Deleter> devices) : m_DeviceList(std::move(devices))
            {}
 
            DeviceListBase(DeviceListBase const&) = default;
            DeviceListBase(DeviceListBase&&) = default;
            // Protected destructor to disallow deletion of derived class through a base class pointer
            ~DeviceListBase() = default;
 
            DeviceListBase& operator=(DeviceListBase const&) = default;
            DeviceListBase& operator=(DeviceListBase&&) = default;
 
        public:
            using size_type = std::size_t;
 
            using iterator = typename PointerVector<T, Deleter>::VectorIterator;
            using const_iterator = typename PointerVector<T, Deleter>::ConstVectorIterator;
 
            iterator begin()
            {
                return m_DeviceList.begin();
            }
 
            const_iterator begin() const
            {
                return m_DeviceList.begin();
            }
 
            const_iterator cbegin() const
            {
                return m_DeviceList.cbegin();
            }
 
            iterator end()
            {
                return m_DeviceList.end();
            }
 
            const_iterator end() const
            {
                return m_DeviceList.end();
            }
 
            const_iterator cend() const
            {
                return m_DeviceList.cend();
            }
 
            bool empty() const
            {
                return m_DeviceList.empty();
            }
 
            size_type size() const
            {
                return m_DeviceList.size();
            }
 
        protected:
            PointerVector<T, Deleter> m_DeviceList;
        };
    }  // namespace internal
}  // namespace pcpp