Clang tidy fixes for Common++ (#1884)

* clang-tidy fixes

* revert '\n'

---------

Co-authored-by: seladb <[email protected]>

Author: egecetin

Common++/header/GeneralUtils.h

@@ -57,12 +57,11 @@ namespace pcpp
 
 	/// A template class to calculate enum class hash
 	/// @tparam EnumClass
-	template <typename EnumClass, typename std::enable_if<std::is_enum<EnumClass>::value, bool>::type = false>
-	struct EnumClassHash
+	template <typename EnumClass, std::enable_if_t<std::is_enum<EnumClass>::value, bool> = false> struct EnumClassHash
 	{
 		size_t operator()(EnumClass value) const
 		{
-			return static_cast<typename std::underlying_type<EnumClass>::type>(value);
+			return static_cast<std::underlying_type_t<EnumClass>>(value);
 		}
 	};
 }  // namespace pcpp

Common++/header/Logger.h

@@ -143,7 +143,7 @@ namespace pcpp
 
 	/// An enum representing the log level. Currently 4 log levels are supported: Off, Error, Info and Debug. Info is
 	/// the default log level
-	enum class LogLevel
+	enum class LogLevel : uint8_t
 	{
 		Off = PCPP_LOG_LEVEL_OFF,      ///< No log messages are emitted.
 		Error = PCPP_LOG_LEVEL_ERROR,  ///< Error level logs are emitted.
@@ -152,9 +152,9 @@ namespace pcpp
 		Debug = PCPP_LOG_LEVEL_DEBUG   ///< Debug level logs and above are emitted.
 	};
 
-	inline std::ostream& operator<<(std::ostream& s, LogLevel v)
+	inline std::ostream& operator<<(std::ostream& ostr, LogLevel lvl)
 	{
-		return s << static_cast<std::underlying_type<LogLevel>::type>(v);
+		return ostr << static_cast<std::underlying_type_t<LogLevel>>(lvl);
 	}
 
 	// Forward declaration
@@ -192,7 +192,7 @@ namespace pcpp
 			/// @brief Appends to the message.
 			/// @param value The value to append.
 			/// @return A reference to this context.
-			template <class T> inline LogContext& operator<<(T const& value)
+			template <class T> LogContext& operator<<(T const& value)
 			{
 				m_Stream << value;
 				return *this;
@@ -245,9 +245,8 @@ namespace pcpp
 		/// @param[in] method The method in PcapPlusPlus code the log message is coming from
 		/// @param[in] line The line in PcapPlusPlus code the log message is coming from
 		/// @remarks The printer callback should support being called from multiple threads simultaneously.
-		using LogPrinter =
-		    std::add_pointer<void(LogLevel logLevel, const std::string& logMessage, const std::string& file,
-		                          const std::string& method, const int line)>::type;
+		using LogPrinter = std::add_pointer_t<void(LogLevel logLevel, const std::string& logMessage,
+		                                           const std::string& file, const std::string& method, const int line)>;
 
 		/// A static method for converting the log level enum to a string.
 		/// @param[in] logLevel A log level enum
@@ -313,7 +312,7 @@ namespace pcpp
 		/// @return Get the last error message
 		std::string getLastError() const
 		{
-			std::lock_guard<std::mutex> lock(m_LastErrorMtx);
+			std::lock_guard<std::mutex> const lock(m_LastErrorMtx);
 			return m_LastError;
 		}
 
@@ -394,7 +393,7 @@ namespace pcpp
 
 	private:
 		bool m_LogsEnabled;
-		std::array<LogLevel, NumOfLogModules> m_LogModulesArray;
+		std::array<LogLevel, NumOfLogModules> m_LogModulesArray{};
 		LogPrinter m_LogPrinter;
 
 		mutable std::mutex m_LastErrorMtx;

Common++/header/MacAddress.h

@@ -57,7 +57,7 @@ namespace pcpp
 		/// A template constructor that creates an instance of the class out of a string convertible to std::string.
 		/// If the string doesn't represent a valid MAC address, the constructor throws an exception.
 		/// @param[in] addr the string representing the MAC address in format "00:00:00:00:00:00"
-		template <typename T, typename = typename std::enable_if<std::is_convertible<T, std::string>::value>::type>
+		template <typename T, typename = std::enable_if_t<std::is_convertible<T, std::string>::value>>
 		MacAddress(const T& addr) : MacAddress(static_cast<std::string>(addr))
 		{}
 

Common++/header/ObjectPool.h

@@ -3,6 +3,7 @@
 #include <stack>
 #include <mutex>
 #include <memory>
+#include <stdexcept>
 #include <limits>
 #include <type_traits>
 
@@ -18,7 +19,7 @@ namespace pcpp
 		/// created. If the pool is full when releasing an object, the object will be deleted.
 		///
 		/// @tparam T The type of objects managed by the pool. Must be default constructable.
-		template <class T, typename std::enable_if<std::is_default_constructible<T>::value, bool>::type = true>
+		template <class T, std::enable_if_t<std::is_default_constructible<T>::value, bool> = true>
 		class DynamicObjectPool
 		{
 		public:
@@ -35,10 +36,14 @@ namespace pcpp
 			    : m_MaxPoolSize(maxPoolSize)
 			{
 				if (initialSize > maxPoolSize)
+				{
 					throw std::invalid_argument("Preallocated objects cannot exceed the maximum pool size");
+				}
 
 				if (initialSize > 0)
+				{
 					this->preallocate(initialSize);
+				}
 			}
 
 			// These don't strictly need to be deleted, but don't need to be implemented for now either.

Common++/header/PointerVector.h

@@ -31,7 +31,7 @@ namespace pcpp
 
 		/// @brief A specialization of Copier to facilitate the safe copying of polymorphic objects via clone() method.
 		/// @tparam T The type of object to copy.
-		template <class T> struct Copier<T, typename std::enable_if<std::is_polymorphic<T>::value>::type>
+		template <class T> struct Copier<T, std::enable_if_t<std::is_polymorphic<T>::value>>
 		{
 			std::unique_ptr<T> operator()(const T& obj) const
 			{

Common++/header/SystemUtils.h

@@ -163,10 +163,10 @@ namespace pcpp
 	int clockGetTime(long& sec, long& nsec);
 
 	/// Convert std::tm to time_t in UTC time, ignoring local timezone
-	/// @param[in] tm The time to convert
+	/// @param[in] time The time to convert
 	/// @return A time_t object representing the input time
 	/// @throws std::runtime_error if a conversion error occurs
-	time_t mkUtcTime(std::tm& tm);
+	time_t mkUtcTime(std::tm& time);
 
 	/// A multi-platform version of the popular sleep method. This method simply runs the right sleep method, according
 	/// to the platform it is running on.

Common++/header/TimespecTimeval.h

@@ -40,9 +40,9 @@ namespace pcpp
 		/// Converts a timespec structure to a timeval structure
 		inline timeval toTimeval(timespec value)
 		{
-			timeval tv = {};
-			TIMESPEC_TO_TIMEVAL(&tv, &value);
-			return tv;
+			timeval tmVal = {};
+			TIMESPEC_TO_TIMEVAL(&tmVal, &value);
+			return tmVal;
 		}
 	}  // namespace internal
 }  // namespace pcpp

Common++/src/Logger.cpp

@@ -85,7 +85,7 @@ namespace pcpp
 		// If the log level is an error, save the error to the last error message variable.
 		if (logLevel == LogLevel::Error)
 		{
-			std::lock_guard<std::mutex> lock(m_LastErrorMtx);
+			std::lock_guard<std::mutex> const lock(m_LastErrorMtx);
 			m_LastError = message;
 		}
 		if (m_LogsEnabled)
@@ -103,7 +103,7 @@ namespace pcpp
 		std::ostringstream sstream;
 		sstream << file << ": " << method << ":" << line;
 
-		std::unique_lock<std::mutex> lock(logMutex);
+		std::unique_lock<std::mutex> const lock(logMutex);
 		std::cerr << std::left << "[" << std::setw(5) << Logger::logLevelAsString(logLevel) << ": " << std::setw(45)
 		          << sstream.str() << "] " << logMessage << std::endl;
 	}

Common++/src/SystemUtils.cpp

@@ -221,12 +221,12 @@ namespace pcpp
 		return 0;
 	}
 
-	time_t mkUtcTime(std::tm& tm)
+	time_t mkUtcTime(std::tm& time)
 	{
 #if defined(_WIN32)
-		return _mkgmtime(&tm);
+		return _mkgmtime(&time);
 #else
-		return timegm(&tm);
+		return timegm(&time);
 #endif
 	}