Added internal::DeviceListBase as a common base for device list classes. (#1790)

* Added base class for device lists.

* Converted `PcapLiveDeviceList` to use `internal::DeviceListBase`.

* Lint

* Removed unused typedefs.

* Revert "Removed unused typedefs."

This reverts commit c051dd3.

* Removed unused typedefs.

Author: Dimi1010

Pcap++/CMakeLists.txt

@@ -28,6 +28,7 @@ add_library(
 set(
   public_headers
   header/Device.h
+  header/DeviceListBase.h
   header/NetworkUtils.h
   header/PcapDevice.h
   header/PcapFileDevice.h

Pcap++/header/DeviceListBase.h

@@ -0,0 +1,85 @@
+#pragma once
+#include "PointerVector.h"
+
+namespace pcpp
+{
+	namespace internal
+	{
+		/// @brief A base class for device lists, providing common functionality for managing a list of devices.
+		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;
+
+			/// @brief Get an iterator to the beginning of the device list
+			iterator begin()
+			{
+				return m_DeviceList.begin();
+			}
+
+			/// @brief Get an iterator to the beginning of the device list
+			const_iterator begin() const
+			{
+				return m_DeviceList.begin();
+			}
+
+			/// @brief Get a const iterator to the beginning of the device list
+			const_iterator cbegin() const
+			{
+				return m_DeviceList.cbegin();
+			}
+
+			/// @brief Get an iterator to the end of the device list
+			iterator end()
+			{
+				return m_DeviceList.end();
+			}
+
+			/// @brief Get an iterator to the end of the device list
+			const_iterator end() const
+			{
+				return m_DeviceList.end();
+			}
+
+			/// @brief Get a const iterator to the end of the device list
+			const_iterator cend() const
+			{
+				return m_DeviceList.cend();
+			}
+
+			/// @brief Check if the device list is empty
+			/// @return True if the device list is empty, false otherwise
+			bool empty() const
+			{
+				return m_DeviceList.empty();
+			}
+
+			/// @brief Get the number of devices in the list
+			/// @return The number of devices in the list
+			size_type size() const
+			{
+				return m_DeviceList.size();
+			}
+
+		protected:
+			PointerVector<T, Deleter> m_DeviceList;
+		};
+	}  // namespace internal
+}  // namespace pcpp

Pcap++/header/PcapLiveDeviceList.h

@@ -2,6 +2,7 @@
 
 #include "DeprecationUtils.h"
 #include "IpAddress.h"
+#include "DeviceListBase.h"
 #include "PcapLiveDevice.h"
 #include <vector>
 #include <memory>
@@ -17,10 +18,11 @@ namespace pcpp
 	/// (on Windows) instances. All live devices are initialized on startup and wrap the network interfaces installed on
 	/// the machine. This class enables access to them through their IP addresses or get a vector of all of them so the
 	/// user can search them in some other way
-	class PcapLiveDeviceList
+	class PcapLiveDeviceList : public internal::DeviceListBase<PcapLiveDevice>
 	{
 	private:
-		std::vector<std::unique_ptr<PcapLiveDevice>> m_LiveDeviceList;
+		using Base = internal::DeviceListBase<PcapLiveDevice>;
+
 		// Vector of raw device pointers to keep the signature of getPcapLiveDevicesList, as it returns a reference.
 		std::vector<PcapLiveDevice*> m_LiveDeviceListView;
 
@@ -29,7 +31,7 @@ namespace pcpp
 		// private c'tor
 		PcapLiveDeviceList();
 
-		static std::vector<std::unique_ptr<PcapLiveDevice>> fetchAllLocalDevices();
+		static PointerVector<PcapLiveDevice> fetchAllLocalDevices();
 		static std::vector<IPv4Address> fetchDnsServers();
 
 	public:

Pcap++/src/PcapLiveDeviceList.cpp

@@ -26,24 +26,23 @@ namespace pcpp
 {
 	namespace
 	{
-		void syncPointerVectors(std::vector<std::unique_ptr<PcapLiveDevice>> const& mainVector,
+		void syncPointerVectors(PointerVector<PcapLiveDevice> const& mainVector,
 		                        std::vector<PcapLiveDevice*>& viewVector)
 		{
 			viewVector.resize(mainVector.size());
 			// Full update of all elements of the view vector to synchronize them with the main vector.
-			std::transform(mainVector.begin(), mainVector.end(), viewVector.begin(),
-			               [](const std::unique_ptr<PcapLiveDevice>& ptr) { return ptr.get(); });
+			std::copy(mainVector.begin(), mainVector.end(), viewVector.begin());
 		}
 	}  // namespace
 
-	PcapLiveDeviceList::PcapLiveDeviceList() : m_LiveDeviceList(fetchAllLocalDevices()), m_DnsServers(fetchDnsServers())
+	PcapLiveDeviceList::PcapLiveDeviceList() : Base(fetchAllLocalDevices()), m_DnsServers(fetchDnsServers())
 	{
-		syncPointerVectors(m_LiveDeviceList, m_LiveDeviceListView);
+		syncPointerVectors(m_DeviceList, m_LiveDeviceListView);
 	}
 
-	std::vector<std::unique_ptr<PcapLiveDevice>> PcapLiveDeviceList::fetchAllLocalDevices()
+	PointerVector<PcapLiveDevice> PcapLiveDeviceList::fetchAllLocalDevices()
 	{
-		std::vector<std::unique_ptr<PcapLiveDevice>> deviceList;
+		PointerVector<PcapLiveDevice> deviceList;
 		std::unique_ptr<pcap_if_t, internal::PcapFreeAllDevsDeleter> interfaceList;
 		try
 		{
@@ -65,7 +64,7 @@ namespace pcpp
 #else  //__linux__, __APPLE__, __FreeBSD__
 			auto dev = std::unique_ptr<PcapLiveDevice>(new PcapLiveDevice(currInterface, true, true, true));
 #endif
-			deviceList.push_back(std::move(dev));
+			deviceList.pushBack(std::move(dev));
 		}
 		return deviceList;
 	}
@@ -289,12 +288,11 @@ namespace pcpp
 
 	PcapLiveDevice* PcapLiveDeviceList::getDeviceByIp(const IPv4Address& ipAddr) const
 	{
-		auto it = std::find_if(m_LiveDeviceList.begin(), m_LiveDeviceList.end(),
-		                       [&ipAddr](std::unique_ptr<PcapLiveDevice> const& devPtr) {
-			                       auto devIP = devPtr->getIPv4Address();
-			                       return devIP == ipAddr;
-		                       });
-		return it != m_LiveDeviceList.end() ? it->get() : nullptr;
+		auto it = std::find_if(m_DeviceList.begin(), m_DeviceList.end(), [&ipAddr](PcapLiveDevice const* devPtr) {
+			auto devIP = devPtr->getIPv4Address();
+			return devIP == ipAddr;
+		});
+		return it != m_DeviceList.end() ? *it : nullptr;
 	}
 
 	PcapLiveDevice* PcapLiveDeviceList::getPcapLiveDeviceByIp(const IPv6Address& ip6Addr) const
@@ -304,12 +302,11 @@ namespace pcpp
 
 	PcapLiveDevice* PcapLiveDeviceList::getDeviceByIp(const IPv6Address& ip6Addr) const
 	{
-		auto it = std::find_if(m_LiveDeviceList.begin(), m_LiveDeviceList.end(),
-		                       [&ip6Addr](std::unique_ptr<PcapLiveDevice> const& devPtr) {
-			                       auto devIP = devPtr->getIPv6Address();
-			                       return devIP == ip6Addr;
-		                       });
-		return it != m_LiveDeviceList.end() ? it->get() : nullptr;
+		auto it = std::find_if(m_DeviceList.begin(), m_DeviceList.end(), [&ip6Addr](PcapLiveDevice const* devPtr) {
+			auto devIP = devPtr->getIPv6Address();
+			return devIP == ip6Addr;
+		});
+		return it != m_DeviceList.end() ? *it : nullptr;
 	}
 
 	PcapLiveDevice* PcapLiveDeviceList::getPcapLiveDeviceByIp(const std::string& ipAddrAsString) const
@@ -342,17 +339,16 @@ namespace pcpp
 	PcapLiveDevice* PcapLiveDeviceList::getDeviceByName(const std::string& name) const
 	{
 		PCPP_LOG_DEBUG("Searching all live devices...");
-		auto devIter =
-		    std::find_if(m_LiveDeviceList.begin(), m_LiveDeviceList.end(),
-		                 [&name](const std::unique_ptr<PcapLiveDevice>& dev) { return dev->getName() == name; });
+		auto devIter = std::find_if(m_DeviceList.begin(), m_DeviceList.end(),
+		                            [&name](PcapLiveDevice* dev) { return dev->getName() == name; });
 
-		if (devIter == m_LiveDeviceList.end())
+		if (devIter == m_DeviceList.end())
 		{
 			PCPP_LOG_DEBUG("Found no live device with name '" << name << "'");
 			return nullptr;
 		}
 
-		return devIter->get();
+		return *devIter;
 	}
 
 	PcapLiveDevice* PcapLiveDeviceList::getPcapLiveDeviceByIpOrName(const std::string& ipOrName) const
@@ -382,10 +378,10 @@ namespace pcpp
 	{
 		m_LiveDeviceListView.clear();
 
-		m_LiveDeviceList = fetchAllLocalDevices();
+		m_DeviceList = fetchAllLocalDevices();
 		m_DnsServers = fetchDnsServers();
 
-		syncPointerVectors(m_LiveDeviceList, m_LiveDeviceListView);
+		syncPointerVectors(m_DeviceList, m_LiveDeviceListView);
 	}
 
 }  // namespace pcpp