[WIP] Attempt to flatten the BgpLayer inheritance chain.

Common++/CMakeLists.txt

@@ -15,6 +15,7 @@ add_library(
 set(
   public_headers
   header/DeprecationUtils.h
+  header/EnumFlagUtils.h
   header/GeneralUtils.h
   header/IpAddress.h
   header/IpAddressUtils.h

Common++/header/EnumFlagUtils.h

@@ -0,0 +1,80 @@
+#pragma once
+
+#include <type_traits>
+
+namespace pcpp
+{
+	namespace internal
+	{
+		template <typename EnumClass> struct EnableBitMaskOperators : std::false_type
+		{
+		};
+
+		template <typename EnumClass>
+		using EnableIfBitMask = typename std::enable_if<EnableBitMaskOperators<EnumClass>::value, EnumClass>::type;
+
+		template <typename EnumClass> constexpr EnableIfBitMask<EnumClass> operator|(EnumClass lhs, EnumClass rhs)
+		{
+			return static_cast<EnumClass>(static_cast<typename std::underlying_type<EnumClass>::type>(lhs) |
+			                              static_cast<typename std::underlying_type<EnumClass>::type>(rhs));
+		}
+
+		template <typename EnumClass> constexpr EnableIfBitMask<EnumClass> operator&(EnumClass lhs, EnumClass rhs)
+		{
+			return static_cast<EnumClass>(static_cast<typename std::underlying_type<EnumClass>::type>(lhs) &
+			                              static_cast<typename std::underlying_type<EnumClass>::type>(rhs));
+		}
+
+		template <typename EnumClass> constexpr EnableIfBitMask<EnumClass> operator^(EnumClass lhs, EnumClass rhs)
+		{
+			return static_cast<EnumClass>(static_cast<typename std::underlying_type<EnumClass>::type>(lhs) ^
+			                              static_cast<typename std::underlying_type<EnumClass>::type>(rhs));
+		}
+
+		template <typename EnumClass> constexpr EnableIfBitMask<EnumClass> operator~(EnumClass rhs)
+		{
+			return static_cast<EnumClass>(~static_cast<typename std::underlying_type<EnumClass>::type>(rhs));
+		}
+
+		template <typename EnumClass> constexpr EnableIfBitMask<EnumClass>& operator|=(EnumClass& lhs, EnumClass rhs)
+		{
+			return lhs = lhs | rhs;
+		}
+
+		template <typename EnumClass> constexpr EnableIfBitMask<EnumClass>& operator&=(EnumClass& lhs, EnumClass rhs)
+		{
+			return lhs = lhs & rhs;
+		}
+
+		template <typename EnumClass> constexpr EnableIfBitMask<EnumClass>& operator^=(EnumClass& lhs, EnumClass rhs)
+		{
+			return lhs = lhs ^ rhs;
+		}
+
+		template <typename EnumClass> constexpr bool hasFlag(EnableIfBitMask<EnumClass> value, EnumClass flag)
+		{
+			return (value & flag) == flag;
+		}
+	}  // namespace internal
+}  // namespace pcpp
+
+#define PCPP_DECLARE_ENUM_FLAG(EnumClass)                                                                              \
+	namespace pcpp                                                                                                     \
+	{                                                                                                                  \
+		namespace internal                                                                                             \
+		{                                                                                                              \
+			template <> struct EnableBitMaskOperators<EnumClass> : std::true_type                                      \
+			{                                                                                                          \
+			};                                                                                                         \
+		}                                                                                                              \
+	}
+
+#define PCPP_USING_ENUM_FLAG_OPERATORS()                                                                               \
+	using ::pcpp::internal::operator|;                                                                                 \
+	using ::pcpp::internal::operator&;                                                                                 \
+	using ::pcpp::internal::operator^;                                                                                 \
+	using ::pcpp::internal::operator~;                                                                                 \
+	using ::pcpp::internal::operator|=;                                                                                \
+	using ::pcpp::internal::operator&=;                                                                                \
+	using ::pcpp::internal::operator^=;                                                                                \
+	using ::pcpp::internal::hasFlag;

Common++/header/IpAddress.h

@@ -106,6 +106,15 @@ namespace pcpp
 			return !(*this == rhs);
 		}
 
+        /// @brief Apply a subnet mask to the address
+		/// @param prefixLen The prefix length of the subnet mask (0-32)
+		/// @throws std::invalid_argument If the prefix length is not between 0 and 32
+        void applySubnetMask(uint8_t prefixLen);
+
+		/// @brief Apply a subnet mask to the address
+		/// @param mask The subnet mask to apply
+		void applySubnetMask(const IPv4Address& mask);
+
 		/// Checks whether the address matches a network.
 		/// @param network An IPv4Network network
 		/// @return True if the address matches the network or false otherwise
@@ -138,6 +147,7 @@ namespace pcpp
 		static const IPv4Address MulticastRangeUpperBound;
 
 	private:
+		// Stored address in network byte order
 		std::array<uint8_t, 4> m_Bytes = { 0 };
 	};  // class IPv4Address
 

Common++/src/IpAddress.cpp

@@ -54,6 +54,27 @@ namespace pcpp
 		}
 	}
 
+	void IPv4Address::applySubnetMask(uint8_t prefixLen)
+	{
+		if (prefixLen > 32)
+		{
+			throw std::invalid_argument("prefixLen must be an integer between 0 and 32");
+		}
+		const uint32_t mask = 0xffffffff ^ (prefixLen < 32 ? 0xffffffff >> prefixLen : 0);
+		m_Bytes[0] &= mask >> 24;
+		m_Bytes[1] &= mask >> 16;
+		m_Bytes[2] &= mask >> 8;
+		m_Bytes[3] &= mask;
+	}
+
+	void IPv4Address::applySubnetMask(const IPv4Address& maskAddress)
+	{
+		m_Bytes[0] &= maskAddress.m_Bytes[0];
+		m_Bytes[1] &= maskAddress.m_Bytes[1];
+		m_Bytes[2] &= maskAddress.m_Bytes[2];
+		m_Bytes[3] &= maskAddress.m_Bytes[3];
+	}
+
 	bool IPv4Address::matchNetwork(const IPv4Network& network) const
 	{
 		return network.includes(*this);