diff --git a/.github/workflows/docker-image.yml b/.github/workflows/docker-image.yml
index a884deb1..f4db89f5 100644
--- a/.github/workflows/docker-image.yml
+++ b/.github/workflows/docker-image.yml
@@ -14,7 +14,7 @@ jobs:
       - name: Run clang-format style check
         uses: jidicula/clang-format-action@v4.11.0
         with:
-          clang-format-version: '10'
+          clang-format-version: '18'
           exclude-regex: .*\.proto
 
   build-unittest:
diff --git a/autotest/autotest.cpp b/autotest/autotest.cpp
index 4f38664a..5a3cef86 100644
--- a/autotest/autotest.cpp
+++ b/autotest/autotest.cpp
@@ -1,6 +1,6 @@
 #include <arpa/inet.h>
+#include <cstring>
 #include <pcap.h>
-#include <string.h>
 #include <sys/shm.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
@@ -11,14 +11,17 @@
 
 #include <experimental/filesystem>
 #include <fstream>
-#include <iostream>
 #include <thread>
+#include <utility>
 
 #include <gmock/gmock.h>
 
 #include "autotest.h"
 #include "common.h"
 
+#include "common/sdpclient.h"
+#include "common/utils.h"
+
 #define MAX_PACK_LEN 16384
 #define SOCK_DEV_PREFIX "sock_dev:"
 
@@ -56,15 +59,11 @@ tAutotest::tAutotest() :
 	::testing::GTEST_FLAG(throw_on_failure) = true;
 }
 
-tAutotest::~tAutotest()
-{
-}
-
 eResult tAutotest::init(const std::string& binaryPath,
                         bool dumpPackets,
                         const std::vector<std::string>& configFilePaths)
 {
-	(void)binaryPath;
+	YANET_GCC_BUG_UNUSED(binaryPath);
 	this->dumpPackets = dumpPackets;
 	this->configFilePaths = configFilePaths;
 
@@ -126,9 +125,9 @@ eResult tAutotest::initSharedMemory()
 	dataPlaneSharedMemory = dataPlane.get_shm_info();
 
 	std::map<key_t, void*> shm_by_key;
-	key_t ipcKey;
-	int shmid;
-	void* shmaddr;
+	key_t ipcKey = 0;
+	int shmid = 0;
+	void* shmaddr = nullptr;
 
 	for (const auto& shmInfo : dataPlaneSharedMemory)
 	{
@@ -141,10 +140,10 @@ eResult tAutotest::initSharedMemory()
 			return eResult::errorInitSharedMemory;
 		}
 
-		shmaddr = shmat(shmid, NULL, 0);
+		shmaddr = shmat(shmid, nullptr, 0);
 		if (shmaddr == (void*)-1)
 		{
-			YANET_LOG_ERROR("shmat(%d, NULL, 0) = %d\n", shmid, errno);
+			YANET_LOG_ERROR("shmat(%d, nullptr, 0) = %d\n", shmid, errno);
 			return eResult::errorInitSharedMemory;
 		}
 
@@ -240,8 +239,8 @@ void tAutotest::sendThread(std::string interfaceName,
 		throw "";
 	}
 
-	pcap_pkthdr* header;
-	const u_char* data;
+	pcap_pkthdr* header = nullptr;
+	const u_char* data = nullptr;
 	static u_char zeros[MAX_PACK_LEN];
 
 	auto iface = pcaps[interfaceName];
@@ -411,10 +410,10 @@ class TextDumper
 class PcapDumper
 {
 public:
-	PcapDumper(const std::string& path, int capsize = MAX_PACK_LEN) :
-	        tmpFilePath(path)
+	PcapDumper(std::string path, int capsize = MAX_PACK_LEN) :
+	        tmpFilePath(std::move(path)), pcap(pcap_open_dead(DLT_EN10MB, capsize))
 	{
-		pcap = pcap_open_dead(DLT_EN10MB, capsize);
+
 		if (!pcap)
 		{
 			YANET_LOG_ERROR("error: pcap_open_dead()\n");
@@ -441,7 +440,7 @@ class PcapDumper
 		pcap_dump((u_char*)dumper, header, data);
 	}
 
-	std::string path() const
+	[[nodiscard]] std::string path() const
 	{
 		return tmpFilePath;
 	}
@@ -479,7 +478,7 @@ class pcap_expectation
 {
 public:
 	pcap_expectation(std::string filename) :
-	        filename(filename), has_packet(true), packetsCount(0), buffer(MAX_PACK_LEN, 0)
+	        filename(filename), buffer(MAX_PACK_LEN, 0)
 	{
 		char pcap_errbuf[PCAP_ERRBUF_SIZE];
 		pcap = pcap_open_offline(filename.c_str(), pcap_errbuf);
@@ -509,8 +508,8 @@ class pcap_expectation
 		{
 			return;
 		}
-		pcap_pkthdr* h = 0;
-		const u_char* data = 0;
+		pcap_pkthdr* h = nullptr;
+		const u_char* data = nullptr;
 		if (pcap_next_ex(pcap, &h, &data) >= 0)
 		{
 			memcpy(&header, h, sizeof(struct pcap_pkthdr));
@@ -529,7 +528,7 @@ class pcap_expectation
 		}
 	}
 
-	bool has_unmatched_packets() const
+	[[nodiscard]] bool has_unmatched_packets() const
 	{
 		return has_packet;
 	}
@@ -541,22 +540,22 @@ class pcap_expectation
 		       !memcmp(buffer.data(), packet, packetSize);
 	}
 
-	std::string location() const
+	[[nodiscard]] std::string location() const
 	{
 		return filename + ":" + std::to_string(packetsCount);
 	}
 
-	int expected_len() const
+	[[nodiscard]] int expected_len() const
 	{
 		return header.len;
 	}
 
-	const u_char* begin() const
+	[[nodiscard]] const u_char* begin() const
 	{
 		return buffer.data();
 	}
 
-	const u_char* end() const
+	[[nodiscard]] const u_char* end() const
 	{
 		return buffer.data() + header.len;
 	}
@@ -571,9 +570,9 @@ class pcap_expectation
 
 private:
 	std::string filename;
-	bool has_packet;
+	bool has_packet{true};
 	struct pcap_pkthdr header;
-	uint64_t packetsCount;
+	uint64_t packetsCount{};
 	pcap_t* pcap;
 	std::vector<u_char> buffer;
 };
@@ -720,7 +719,7 @@ void tAutotest::recvThread(std::string interfaceName,
 
 			auto packetSize = tmp_pcap_packetHeader.len;
 			YANET_LOG_DEBUG("unexpected %u\n", packetSize);
-			dumper.dump(NULL, NULL, buffer, buffer + packetSize);
+			dumper.dump(nullptr, nullptr, buffer, buffer + packetSize);
 		}
 
 		success = false;
@@ -743,21 +742,6 @@ void tAutotest::recvThread(std::string interfaceName,
 	unlink(pcapDumper.path().data());
 }
 
-std::vector<std::string> split(const std::string& string,
-                               char delimiter = ' ')
-{
-	std::vector<std::string> result;
-
-	std::stringstream stream(string);
-	std::string item;
-	while (std::getline(stream, item, delimiter))
-	{
-		result.emplace_back(item);
-	}
-
-	return result;
-}
-
 bool tAutotest::step_ipv4Update(const YAML::Node& yamlStep)
 {
 	if (yamlStep.IsScalar())
@@ -873,10 +857,10 @@ bool tAutotest::step_checkCounters(const YAML::Node& yamlStep)
 	auto fwList = controlPlane.getFwList(common::icp::getFwList::requestType::static_rules_original);
 	for (auto& [ruleno, rules] : fwList)
 	{
-		(void)ruleno;
+		YANET_GCC_BUG_UNUSED(ruleno);
 		for (auto& [id, counter, text] : rules)
 		{
-			(void)text;
+			YANET_GCC_BUG_UNUSED(text);
 			counters[id] = counter;
 		}
 	}
@@ -895,7 +879,7 @@ bool tAutotest::step_sendPackets(const YAML::Node& yamlStep,
 
 	for (const auto& yamlPort : yamlStep)
 	{
-		std::string interfaceName = yamlPort["port"].as<std::string>();
+		auto interfaceName = yamlPort["port"].as<std::string>();
 
 		if (yamlPort["send"])
 		{
@@ -1198,9 +1182,9 @@ bool tAutotest::step_rib_clear(const YAML::Node& yaml)
 
 		if (yaml_attribute["peer"].IsDefined() && yaml_attribute["vrf"].IsDefined() && yaml_attribute["priority"].IsDefined())
 		{
-			std::string peer = yaml_attribute["peer"].as<std::string>();
-			std::string vrf = yaml_attribute["vrf"].as<std::string>();
-			uint32_t priority = yaml_attribute["priority"].as<uint32_t>();
+			auto peer = yaml_attribute["peer"].as<std::string>();
+			auto vrf = yaml_attribute["vrf"].as<std::string>();
+			auto priority = yaml_attribute["priority"].as<uint32_t>();
 
 			std::tuple<std::string, uint32_t> vrf_priority_tup(std::move(vrf), std::move(priority));
 			std::tuple<ip_address_t, std::tuple<std::string, uint32_t>> peer_vrf_priority_tup(std::move(peer), std::move(vrf_priority_tup));
@@ -1537,7 +1521,7 @@ void tAutotest::convert_ipv4Update(const std::string& string)
 
 	convert_ipv4Remove(prefix);
 
-	for (const auto& nexthop : split(nexthops))
+	for (const auto& nexthop : utils::split(nexthops, ' '))
 	{
 		common::icp::rib_update::insert request = {"autotest", "default", YANET_RIB_PRIORITY_DEFAULT, {}};
 		std::get<3>(request)[attribute_default]["ipv4"][nexthop].emplace_back(prefix,
@@ -1574,7 +1558,7 @@ void tAutotest::convert_ipv4LabelledUpdate(const std::string& string)
 
 	convert_ipv4LabelledRemove(prefix);
 
-	for (const auto& nexthop_label : split(nexthops))
+	for (const auto& nexthop_label : utils::split(nexthops, ' '))
 	{
 		std::string nexthop = nexthop_label.substr(0, nexthop_label.find(":"));
 		std::string label = nexthop_label.substr(nexthop_label.find(":") + 1);
@@ -1618,7 +1602,7 @@ void tAutotest::convert_ipv6Update(const std::string& string)
 	std::string prefix = string.substr(0, string.find(" -> "));
 	std::string nexthops = string.substr(string.find(" -> ") + 4);
 
-	for (const auto& nexthop : split(nexthops))
+	for (const auto& nexthop : utils::split(nexthops, ' '))
 	{
 		common::icp::rib_update::insert request = {"autotest", "default", YANET_RIB_PRIORITY_DEFAULT, {}};
 		std::get<3>(request)[attribute_default]["ipv6"][nexthop].emplace_back(prefix,
@@ -1635,7 +1619,7 @@ void tAutotest::convert_ipv6LabelledUpdate(const std::string& string)
 	std::string prefix = string.substr(0, string.find(" -> "));
 	std::string nexthops = string.substr(string.find(" -> ") + 4);
 
-	for (const auto& nexthop_label : split(nexthops))
+	for (const auto& nexthop_label : utils::split(nexthops, ' '))
 	{
 		std::string nexthop = nexthop_label.substr(0, nexthop_label.find("|"));
 		std::string label = nexthop_label.substr(nexthop_label.find("|") + 1);
@@ -1864,7 +1848,7 @@ std::string exec(const char* cmd)
 
 	try
 	{
-		while (fgets(buffer, sizeof buffer, pipe) != NULL)
+		while (fgets(buffer, sizeof buffer, pipe) != nullptr)
 		{
 			result += buffer;
 		}
@@ -1916,7 +1900,7 @@ common::bufferring::item_t* read_shm_packet(common::bufferring* buffer, uint64_t
 	{
 		return nullptr;
 	}
-	common::bufferring::item_t* item = (common::bufferring::item_t*)((uintptr_t)buffer->ring->memory + (position * buffer->unit_size));
+	auto* item = (common::bufferring::item_t*)((uintptr_t)buffer->ring->memory + (position * buffer->unit_size));
 	return item;
 }
 
@@ -1926,11 +1910,11 @@ bool tAutotest::step_dumpPackets(const YAML::Node& yamlStep,
 	TextDumper dumper;
 	for (const auto& yamlDump : yamlStep)
 	{
-		std::string tag = yamlDump["ringTag"].as<std::string>();
+		auto tag = yamlDump["ringTag"].as<std::string>();
 		std::string expectFilePath = path + "/" + yamlDump["expect"].as<std::string>();
 		bool success = true;
 
-		common::bufferring* ring;
+		common::bufferring* ring = nullptr;
 		{ /// searching memory ring by tag
 			auto it = dumpRings.find(tag);
 			if (it == dumpRings.end())
@@ -1941,7 +1925,7 @@ bool tAutotest::step_dumpPackets(const YAML::Node& yamlStep,
 			ring = &it->second;
 		}
 
-		pcap_t* pcap;
+		pcap_t* pcap = nullptr;
 		{ /// open pcap file with expected data
 			char pcap_errbuf[PCAP_ERRBUF_SIZE];
 			pcap = pcap_open_offline(expectFilePath.data(), pcap_errbuf);
@@ -1953,8 +1937,8 @@ bool tAutotest::step_dumpPackets(const YAML::Node& yamlStep,
 		}
 
 		struct pcap_pkthdr header;
-		const u_char* pcap_packet;
-		common::bufferring::item_t* shm_packet;
+		const u_char* pcap_packet = nullptr;
+		common::bufferring::item_t* shm_packet = nullptr;
 		uint64_t position = 0;
 
 		/// read packets from pcap and compare them with packets from memory ring
@@ -1998,7 +1982,7 @@ bool tAutotest::step_dumpPackets(const YAML::Node& yamlStep,
 			if (dumpPackets)
 			{
 				YANET_LOG_DEBUG("dump [%s]: unexpected %u\n", tag.data(), shm_packet->header.size);
-				dumper.dump(NULL, NULL, shm_packet->memory, shm_packet->memory + header.len);
+				dumper.dump(nullptr, nullptr, shm_packet->memory, shm_packet->memory + header.len);
 			}
 		}
 
@@ -2023,4 +2007,4 @@ void tAutotest::fflushSharedMemory()
 	memset(memaddr, 0, size);
 }
 
-} // namespace autotest
\ No newline at end of file
+} // namespace autotest
diff --git a/autotest/autotest.h b/autotest/autotest.h
index 873e9ef4..1725a16c 100644
--- a/autotest/autotest.h
+++ b/autotest/autotest.h
@@ -11,7 +11,7 @@
 #include "common/icontrolplane.h"
 #include "common/idataplane.h"
 #include "common/result.h"
-#include "common/sdpclient.h"
+#include "common/sdpcommon.h"
 
 namespace nAutotest
 {
@@ -36,7 +36,7 @@ class tAutotest
 {
 public:
 	tAutotest();
-	~tAutotest();
+	~tAutotest() = default;
 
 	eResult init(const std::string& binaryPath,
 	             bool dumpPackets,
diff --git a/autotest/main.cpp b/autotest/main.cpp
index eedeade2..f007132d 100644
--- a/autotest/main.cpp
+++ b/autotest/main.cpp
@@ -1,6 +1,4 @@
-#include <signal.h>
-
-#include <iostream>
+#include <csignal>
 
 #include "common/result.h"
 
@@ -45,7 +43,7 @@ int main(int argc,
 	/** @todo
 	if (signal(SIGINT, handleSignal) == SIG_ERR)
 	{
-		return 3;
+	        return 3;
 	}
 	*/
 
diff --git a/cli/acl.h b/cli/acl.h
index 7579300f..5f143e0f 100644
--- a/cli/acl.h
+++ b/cli/acl.h
@@ -1,8 +1,9 @@
 #pragma once
 
+#include "cli/helper.h"
 #include "common/icontrolplane.h"
 
-#include "helper.h"
+#include "table_printer.h"
 
 namespace acl
 {
@@ -52,39 +53,21 @@ void unwind(const std::string& in_module,
 	                                         transport_flags,
 	                                         recordstate});
 
-	table_t table({.optional_null = "any"});
-	table.insert("module",
-	             "direction",
-	             "network_source",
-	             "network_destination",
-	             "fragment",
-	             "protocol",
-	             "transport_source",
-	             "transport_destination",
-	             "transport_flags",
-	             "recordstate",
-	             "next_module",
-	             "ids",
-	             "log");
-
-	for (const auto& [module, direction, network_source, network_destination, fragment, protocol, transport_source, transport_destination, transport_flags, recordstate, next_module, ids, log] : response)
-	{
-		table.insert(module,
-		             direction,
-		             network_source,
-		             network_destination,
-		             fragment,
-		             protocol,
-		             transport_source,
-		             transport_destination,
-		             transport_flags,
-		             recordstate,
-		             next_module,
-		             ids,
-		             log);
-	}
-
-	table.print();
+	FillAndPrintTable({"module",
+	                   "direction",
+	                   "network_source",
+	                   "network_destination",
+	                   "fragment",
+	                   "protocol",
+	                   "transport_source",
+	                   "transport_destination",
+	                   "transport_flags",
+	                   "recordstate",
+	                   "next_module",
+	                   "ids",
+	                   "log"},
+	                  response,
+	                  {.optional_null = "any"});
 }
 
 void lookup(std::optional<std::string> module,
@@ -113,19 +96,7 @@ void lookup(std::optional<std::string> module,
 	                                         transport_source,
 	                                         transport_destination});
 
-	table_t table;
-	table.insert("ruleno",
-	             "label",
-	             "rule");
-
-	for (const auto& [ruleno, label, rule] : response)
-	{
-		table.insert(ruleno,
-		             label,
-		             rule);
-	}
-
-	table.print();
+	FillAndPrintTable({"ruleno", "label", "rule"}, response);
 }
 
 }
diff --git a/cli/balancer.h b/cli/balancer.h
index 5ca6b260..5d7acd71 100644
--- a/cli/balancer.h
+++ b/cli/balancer.h
@@ -1,12 +1,12 @@
 #pragma once
 
+#include "cli/helper.h"
 #include "common/icontrolplane.h"
-#include "common/icp_proto.h"
 #include "common/idataplane.h"
 #include "common/iproto_controlplane.h"
 #include "common/type.h"
 
-#include "helper.h"
+#include "table_printer.h"
 
 namespace balancer
 {
@@ -16,25 +16,13 @@ void summary()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.balancer_summary();
 
-	table_t table;
-	table.insert("module",
-	             "services",
-	             "reals_enabled",
-	             "reals",
-	             "connections",
-	             "next_module");
-
-	for (const auto& [module, services, reals_enabled, reals, connections, next_module] : response)
-	{
-		table.insert(module,
-		             services,
-		             reals_enabled,
-		             reals,
-		             connections,
-		             next_module);
-	}
-
-	table.print();
+	FillAndPrintTable({"module",
+	                   "services",
+	                   "reals_enabled",
+	                   "reals",
+	                   "connections",
+	                   "next_module"},
+	                  response);
 }
 
 void service(std::string module_string,
@@ -67,16 +55,16 @@ void service(std::string module_string,
 	interface::dataPlane dataplane;
 	auto balancer_service_connections = dataplane.balancer_service_connections();
 
-	table_t table;
-	table.insert("module",
-	             "virtual_ip",
-	             "proto",
-	             "virtual_port",
-	             "scheduler",
-	             "connections",
-	             "packets",
-	             "bytes",
-	             "version");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "virtual_ip",
+	                 "proto",
+	                 "virtual_port",
+	                 "scheduler",
+	                 "connections",
+	                 "packets",
+	                 "bytes",
+	                 "version");
 
 	for (const auto& [module, services] : response)
 	{
@@ -86,7 +74,7 @@ void service(std::string module_string,
 		{
 			const auto& [virtual_ip, proto, virtual_port] = service_key;
 			const auto& [scheduler, version, nap_connections, packets, bytes] = service_value;
-			(void)nap_connections; ///< @todo: DELETE
+			YANET_GCC_BUG_UNUSED(nap_connections); ///< @todo: DELETE
 
 			auto proto_string = controlplane::balancer::from_proto(proto);
 
@@ -98,7 +86,7 @@ void service(std::string module_string,
 			uint32_t connections = 0;
 			for (auto& [socket_id, service_connections] : balancer_service_connections)
 			{
-				(void)socket_id;
+				YANET_GCC_BUG_UNUSED(socket_id);
 
 				const auto& socket_connections = service_connections[key].value;
 				if (socket_connections > connections)
@@ -107,19 +95,19 @@ void service(std::string module_string,
 				}
 			}
 
-			table.insert(module_name,
-			             virtual_ip,
-			             proto_string,
-			             virtual_port,
-			             scheduler,
-			             connections,
-			             packets,
-			             bytes,
-			             version);
+			table.insert_row(module_name,
+			                 virtual_ip,
+			                 proto_string,
+			                 virtual_port,
+			                 scheduler,
+			                 connections,
+			                 packets,
+			                 bytes,
+			                 version);
 		}
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void setip(common::icp_proto::IPAddr* pAddr, const common::ip_address_t& value)
@@ -202,20 +190,20 @@ void real_find(std::string module_string,
 	interface::dataPlane dataplane;
 	auto balancer_real_connections = dataplane.balancer_real_connections();
 
-	table_t table;
-	table.insert("module",
-	             "virtual_ip",
-	             "proto",
-	             "virtual_port",
-	             "scheduler",
-	             "real_ip",
-	             "real_port",
-	             "enabled",
-	             "weight",
-	             "connections",
-	             "packets",
-	             "bytes",
-	             "version");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "virtual_ip",
+	                 "proto",
+	                 "virtual_port",
+	                 "scheduler",
+	                 "real_ip",
+	                 "real_port",
+	                 "enabled",
+	                 "weight",
+	                 "connections",
+	                 "packets",
+	                 "bytes",
+	                 "version");
 
 	for (const auto& balancer : response.balancers())
 	{
@@ -239,7 +227,7 @@ void real_find(std::string module_string,
 				uint32_t connections = 0;
 				for (auto& [socket_id, real_connections] : balancer_real_connections)
 				{
-					(void)socket_id;
+					YANET_GCC_BUG_UNUSED(socket_id);
 
 					const auto& socket_connections = real_connections[key].value;
 					if (socket_connections > connections)
@@ -248,24 +236,24 @@ void real_find(std::string module_string,
 					}
 				}
 
-				table.insert(balancer.module(),
-				             virtual_ip,
-				             proto_string,
-				             service.key().port_opt_case() == common::icp_proto::BalancerRealFindResponse_ServiceKey::PortOptCase::kPort ? std::make_optional(service.key().port()) : std::nullopt,
-				             service.scheduler(),
-				             real_ip,
-				             real.port_opt_case() == common::icp_proto::BalancerRealFindResponse_Real::PortOptCase::kPort ? std::make_optional(real.port()) : std::nullopt,
-				             real.enabled(),
-				             real.weight(),
-				             connections,
-				             real.packets(),
-				             real.bytes(),
-				             service.version_opt_case() == common::icp_proto::BalancerRealFindResponse_Service::VersionOptCase::kVersion ? std::make_optional(service.version()) : std::nullopt);
+				table.insert_row(balancer.module(),
+				                 virtual_ip,
+				                 proto_string,
+				                 service.key().port_opt_case() == common::icp_proto::BalancerRealFindResponse_ServiceKey::PortOptCase::kPort ? std::make_optional(service.key().port()) : std::nullopt,
+				                 service.scheduler(),
+				                 real_ip,
+				                 real.port_opt_case() == common::icp_proto::BalancerRealFindResponse_Real::PortOptCase::kPort ? std::make_optional(real.port()) : std::nullopt,
+				                 real.enabled(),
+				                 real.weight(),
+				                 connections,
+				                 real.packets(),
+				                 real.bytes(),
+				                 service.version_opt_case() == common::icp_proto::BalancerRealFindResponse_Service::VersionOptCase::kVersion ? std::make_optional(service.version()) : std::nullopt);
 			}
 		}
 	}
 
-	table.print();
+	table.Print();
 }
 
 void state(std::string module,
@@ -321,7 +309,7 @@ void state(std::string module,
 	/// @todo: OPT
 	for (const auto& [socket_id, services_real_connections] : response)
 	{
-		(void)socket_id;
+		YANET_GCC_BUG_UNUSED(socket_id);
 
 		for (const auto& [services_real, connections] : services_real_connections)
 		{
@@ -331,7 +319,7 @@ void state(std::string module,
 
 			for (const auto& [client_ip, client_port, timestamp_create, timestamp_last_packet, timestamp_gc] : connections)
 			{
-				(void)timestamp_gc;
+				YANET_GCC_BUG_UNUSED(timestamp_gc);
 
 				auto it = map.find({client_ip, client_port});
 				if (it != map.end())
@@ -351,17 +339,17 @@ void state(std::string module,
 		}
 	}
 
-	table_t table;
-	table.insert("module",
-	             "virtual_ip",
-	             "proto",
-	             "virtual_port",
-	             "real_ip",
-	             "real_port",
-	             "client_ip",
-	             "client_port",
-	             "created",
-	             "last_seen");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "virtual_ip",
+	                 "proto",
+	                 "virtual_port",
+	                 "real_ip",
+	                 "real_port",
+	                 "client_ip",
+	                 "client_port",
+	                 "created",
+	                 "last_seen");
 
 	uint32_t current_time = time(nullptr);
 
@@ -388,22 +376,22 @@ void state(std::string module,
 					const auto& [client_ip, client_port] = key;
 					const auto& [timestamp_create, timestamp_last_packet] = value;
 
-					table.insert(module,
-					             virtual_ip,
-					             proto_string,
-					             virtual_port,
-					             real_ip,
-					             real_port,
-					             client_ip,
-					             client_port,
-					             (uint32_t)current_time - timestamp_create,
-					             (uint16_t)current_time - timestamp_last_packet);
+					table.insert_row(module,
+					                 virtual_ip,
+					                 proto_string,
+					                 virtual_port,
+					                 real_ip,
+					                 real_port,
+					                 client_ip,
+					                 client_port,
+					                 (uint32_t)current_time - timestamp_create,
+					                 (uint16_t)current_time - timestamp_last_packet);
 				}
 			}
 		}
 	}
 
-	table.print();
+	table.Print();
 }
 
 namespace real
@@ -490,17 +478,7 @@ void announce()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.balancer_announce();
 
-	table_t table;
-	table.insert("module",
-	             "announces");
-
-	for (const auto& [module, announces] : response)
-	{
-		table.insert(module,
-		             announces);
-	}
-
-	table.print();
+	FillAndPrintTable({"module", "announces"}, response);
 }
 
 }
diff --git a/cli/bus.h b/cli/bus.h
index e26c2456..ba8cefbb 100644
--- a/cli/bus.h
+++ b/cli/bus.h
@@ -2,6 +2,7 @@
 
 #include "helper.h"
 #include "influxdb_format.h"
+#include "table_printer.h"
 
 namespace bus
 {
@@ -11,7 +12,7 @@ using bus_request_info = std::tuple<std::string, uint64_t, uint64_t>;
 inline std::vector<bus_request_info> get_bus_requests(common::sdp::DataPlaneInSharedMemory& sdp_data)
 {
 	auto [requests, errors, durations] = sdp_data.BuffersBus();
-	(void)errors;
+	YANET_GCC_BUG_UNUSED(errors);
 
 	std::map<common::idp::requestType, std::string> names = {
 	        {common::idp::requestType::updateGlobalBase, "updateGlobalBase"},
@@ -78,24 +79,24 @@ inline void bus_requests()
 	OpenSharedMemoryDataplaneBuffers(sdp_data, false);
 	auto requests = get_bus_requests(sdp_data);
 
-	table_t table;
-	table.insert("request", "count", "duration_ms");
+	TablePrinter table;
+	table.insert_row("request", "count", "duration_ms");
 	for (const auto& [request, count, duration] : requests)
 	{
 		if ((count != 0) || (duration != 0))
 		{
-			table.insert(request, count, duration);
+			table.insert_row(request, count, duration);
 		}
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline std::vector<std::pair<std::string, uint64_t>> get_bus_errors(const common::sdp::DataPlaneInSharedMemory& sdp_data)
 {
 	auto [requests, errors, durations] = sdp_data.BuffersBus();
-	(void)requests;
-	(void)durations;
+	YANET_GCC_BUG_UNUSED(requests);
+	YANET_GCC_BUG_UNUSED(durations);
 
 	std::map<common::idp::errorType, std::string> names = {
 	        {common::idp::errorType::busRead, "busRead"},
@@ -119,14 +120,7 @@ inline void bus_errors()
 	OpenSharedMemoryDataplaneBuffers(sdp_data, false);
 	auto errors = get_bus_errors(sdp_data);
 
-	table_t table;
-	table.insert("error", "count");
-	for (const auto& [error, count] : errors)
-	{
-		table.insert(error, count);
-	}
-
-	table.print();
+	FillAndPrintTable({"error", "count"}, errors);
 }
 
 inline void bus_telegraf()
diff --git a/cli/config.cpp b/cli/config.cpp
index 8d03d107..6e9aa403 100644
--- a/cli/config.cpp
+++ b/cli/config.cpp
@@ -139,16 +139,16 @@ bool allowPrefix(nlohmann::json& prefixes,
 			}
 
 			// check whether current announces includes announceRaw
-			for (auto announceIt = announces->begin(); announceIt != announces->end(); ++announceIt)
+			for (auto& announceIt : *announces)
 			{
 				// sanity check that announce has string type
-				if (!announceIt->is_string())
+				if (!announceIt.is_string())
 				{
 					throw std::string{"invalid type of prefix item announce. Should be string"};
 				}
 
 				// announce already presented within the prefix
-				if (announceIt->get_ref<const std::string&>() == announceRaw)
+				if (announceIt.get_ref<const std::string&>() == announceRaw)
 				{
 					return false;
 				}
@@ -366,7 +366,7 @@ void allow(const std::string& module,
 	checkModuleType(decap, "decap");
 
 	const auto& [prefixes, inserted] = decap.emplace("ipv6DestinationPrefixes", nlohmann::json::array_t{});
-	(void)inserted;
+	YANET_GCC_BUG_UNUSED(inserted);
 
 	if (allowPrefix(*prefixes, prefixRaw, announceRaw))
 	{
@@ -436,7 +436,7 @@ static void allowAny(const std::string& module,
 	checkModuleType(nat64, "nat64stateless");
 
 	const auto& [prefixes, inserted] = nat64.emplace("nat64_prefixes", nlohmann::json::array_t{});
-	(void)inserted;
+	YANET_GCC_BUG_UNUSED(inserted);
 
 	if (allowPrefix(*prefixes, prefixRaw, announceRaw))
 	{
diff --git a/cli/convert.h b/cli/convert.h
index 0c5795bb..a10fc6f1 100644
--- a/cli/convert.h
+++ b/cli/convert.h
@@ -2,6 +2,7 @@
 
 #include "common/icontrolplane.h"
 #include "helper.h"
+#include "table_printer.h"
 
 namespace convert
 {
@@ -11,16 +12,7 @@ inline void logical_module()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.convert("logical_module");
 
-	table_t table;
-	table.insert("id",
-	             "name");
-
-	for (const auto& [id, name] : response)
-	{
-		table.insert(id, name);
-	}
-
-	table.print();
+	FillAndPrintTable({"id", "name"}, response);
 }
 
 } /* namespace convert */
diff --git a/cli/converter.h b/cli/converter.h
index 29043b32..b1db93eb 100644
--- a/cli/converter.h
+++ b/cli/converter.h
@@ -1,12 +1,13 @@
 #pragma once
 
-#include <optional>
 #include <set>
 #include <sstream>
 #include <string>
 #include <variant>
 #include <vector>
 
+#include "common/traits.h"
+
 namespace converter
 {
 
@@ -18,128 +19,73 @@ struct config_t
 	std::string set_empty = "n/s";
 };
 
-template<typename arg_T>
-std::string to_string(const std::optional<arg_T>& value, const config_t config = {});
-template<typename... args_T>
-std::string to_string(const std::variant<args_T...>& value, const config_t config = {});
-template<typename arg_T>
-std::string to_string(const std::vector<arg_T>& vector, const config_t config = {});
-template<typename arg_T>
-std::string to_string(const std::set<arg_T>& set, const config_t config = {});
-std::string to_string(const bool& value, const config_t config = {});
-std::string to_string(const std::string& string, const config_t config = {});
-template<typename arg_T>
-std::string to_string(const arg_T& value, const config_t config = {});
-
-template<typename arg_T>
-std::string to_string(const std::optional<arg_T>& value,
-                      const config_t config)
+template<typename T>
+std::string to_string(const T& value, const config_t& config = {})
 {
-	if (value)
+	if constexpr (std::is_same_v<T, std::string>)
 	{
-		return to_string(*value, config);
+		return value.empty() ? config.string_empty : value;
 	}
-	else
+	else if constexpr (std::is_same_v<T, std::string_view>)
 	{
-		return config.optional_null;
+		return value.empty() ? config.string_empty : std::string(value);
 	}
-};
-
-template<typename... args_T>
-std::string to_string(const std::variant<args_T...>& value,
-                      const config_t config)
-{
-	return std::visit([&config](const auto& value) -> std::string { return to_string(value, config); }, value);
-};
-
-template<typename arg_T>
-std::string to_string(const std::vector<arg_T>& vector,
-                      const config_t config)
-{
-	if (vector.empty())
+	else if constexpr (std::is_constructible_v<std::string, T>)
 	{
-		return config.vector_empty;
+		return value;
 	}
-
-	bool first = true;
-	std::ostringstream result;
-	for (const auto& item : vector)
+	else if constexpr (std::is_same_v<T, bool>)
 	{
-		if (!first)
-		{
-			result << ","; ///< @todo: config
-		}
-
-		result << to_string(item, config);
-		first = false;
+		return value ? "true" : "false";
 	}
-	return result.str();
-}
-
-template<typename arg_T>
-std::string to_string(const std::set<arg_T>& set,
-                      const config_t config)
-{
-	if (set.empty())
+	else if constexpr (std::is_arithmetic_v<T>)
 	{
-		return config.set_empty;
+		return std::to_string(value);
 	}
-
-	bool first = true;
-	std::ostringstream result;
-	for (const auto& item : set)
+	else if constexpr (traits::is_variant_v<T>)
 	{
-		if (!first)
-		{
-			result << ","; ///< @todo: config
-		}
-
-		result << to_string(item, config);
-		first = false;
+		return std::visit([&config](const auto& val) { return to_string(val, config); }, value);
 	}
-	return result.str();
-}
-
-std::string to_string(const bool& value,
-                      const config_t config)
-{
-	(void)config;
-	if (value)
+	else if constexpr (traits::is_optional_v<T>)
 	{
-		return "true";
+		return value ? to_string(*value, config) : config.optional_null;
 	}
-	else
+	else if constexpr (traits::is_container_v<T>)
 	{
-		return "false";
-	}
-};
+		if (value.empty())
+		{
+			if constexpr (traits::is_vector_v<T>)
+			{
+				return config.vector_empty;
+			}
+			else if constexpr (traits::is_set_v<T>)
+			{
+				return config.set_empty;
+			}
+			else
+			{
+				static_assert(traits::always_false_v<T>,
+				              "Container does not have default empty representation in struct config_t");
+			}
+		}
 
-std::string to_string(const std::string& string,
-                      const config_t config)
-{
-	if (string.empty())
-	{
-		return config.string_empty;
-	}
-	else
-	{
-		return string;
-	}
-};
+		std::ostringstream oss;
+		auto it = std::begin(value);
+		oss << to_string(*it, config);
+		++it;
 
-template<typename arg_T>
-std::string to_string(const arg_T& value,
-                      const config_t config)
-{
-	(void)config;
-	if constexpr (std::is_constructible_v<std::string, decltype(value)>)
-	{
-		return value;
+		for (; it != std::end(value); ++it)
+		{
+			oss << ',' << to_string(*it, config);
+		}
+
+		return oss.str();
 	}
 	else
 	{
-		return std::to_string(value);
+		static_assert(std::is_constructible_v<std::string, T>,
+		              "Type is not convertible to std::string and no overload of to_string is provided");
 	}
-};
-
 }
+
+} // namespace converter
diff --git a/cli/develop.h b/cli/develop.h
index 46eba193..b9c3ca67 100644
--- a/cli/develop.h
+++ b/cli/develop.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <array>
 #include <chrono>
 #include <cstdint>
 #include <string>
@@ -7,198 +8,184 @@
 #include <thread>
 #include <vector>
 
-#include "common/icontrolplane.h"
 #include "common/idataplane.h"
 #include "common/sdpclient.h"
+#include "common/shared_memory.h"
 #include "common/tsc_deltas.h"
+#include "common/tuple.h"
 
-#include "helper.h"
+#include "table_printer.h"
 
-namespace develop
+namespace develop::dataplane
 {
 
-namespace dataplane
+static void printValue(const common::idp::value& value)
 {
+	const auto& [type, interface] = value;
+	std::ostringstream oss;
+	using common::globalBase::eNexthopType;
 
-static inline void printValue(const common::idp::value& value)
-{
-	const auto& type = std::get<0>(value);
-	if (type == common::globalBase::eNexthopType::drop)
-	{
-		printf("  drop\n");
-	}
-	else if (type == common::globalBase::eNexthopType::interface)
+	switch (type)
 	{
-		for (const auto& iter : std::get<1>(value))
-		{
-			if (std::get<0>(std::get<1>(iter)) != common::unlabelled)
+		case eNexthopType::drop:
+			oss << "  drop\n";
+			break;
+		case eNexthopType::interface:
+			for (const auto& [interfaceId, transport, service] : interface)
 			{
-				if (std::get<0>(std::get<2>(iter)) != common::unlabelled)
+				const auto& [transport_label, transport_exp] = transport;
+				const auto& [service_label, service_exp] = service;
+
+				if (transport_label != common::unlabelled)
 				{
-					printf("  interfaceId: %u,\ttransport: [label: %u, exp: %u],\tservice: [label: %u, exp: %u]\n",
-					       std::get<0>(iter),
-					       std::get<0>(std::get<1>(iter)),
-					       std::get<1>(std::get<1>(iter)),
-					       std::get<0>(std::get<2>(iter)),
-					       std::get<1>(std::get<2>(iter)));
+					if (service_label != common::unlabelled)
+					{
+						oss << "  interfaceId: " << interfaceId
+						    << ",\ttransport: [label: " << transport_label
+						    << ", exp: " << transport_exp
+						    << "],\tservice: [label: " << service_label
+						    << ", exp: " << service_exp << "]\n";
+					}
+					else
+					{
+						oss << "  interfaceId: " << interfaceId
+						    << ",\ttransport: [label: " << transport_label
+						    << ", exp: " << transport_exp << "]\n";
+					}
 				}
 				else
 				{
-					printf("  interfaceId: %u,\ttransport: [label: %u, exp: %u]\n",
-					       std::get<0>(iter),
-					       std::get<0>(std::get<1>(iter)),
-					       std::get<1>(std::get<1>(iter)));
+					oss << "  interfaceId: " << interfaceId << "\n";
 				}
 			}
-			else
-			{
-				printf("  interfaceId: %u\n",
-				       std::get<0>(iter));
-			}
-		}
-	}
-	else if (type == common::globalBase::eNexthopType::controlPlane)
-	{
-		printf("  controlPlane\n");
-	}
-	else
-	{
-		printf("  error\n");
+			break;
+		case eNexthopType::controlPlane:
+			oss << "  controlPlane\n";
+			break;
+		default:
+			oss << "  error\n";
 	}
+
+	std::cout << oss.str();
 }
 
-void lpm4LookupAddress(const common::ipv4_address_t& address)
+template<typename T>
+static void lpmLookupAddress(const T& address)
 {
 	interface::dataPlane dataPlane;
-	const auto response = dataPlane.lpm4LookupAddress(address);
-	for (const auto& iter : response)
-	{
-		const auto& socketId = iter.first;
-		const auto& found = std::get<0>(iter.second);
-		const auto& valueId = std::get<1>(iter.second);
-		const auto& value = std::get<2>(iter.second);
 
-		printf("[socketId: %u] %s -> ", socketId, common::ipv4_address_t(address).toString().data());
-		if (found)
+	const auto& response = [&]() {
+		if constexpr (std::is_same_v<T, common::ipv4_address_t>)
 		{
-			printf("valueId: %u\n", valueId);
-			printValue(value);
+			return dataPlane.lpm4LookupAddress(address);
+		}
+		else if constexpr (std::is_same_v<T, common::ipv6_address_t>)
+		{
+			return dataPlane.lpm6LookupAddress(address);
 		}
 		else
 		{
-			printf("not found\n");
+			static_assert(traits::always_false_v<T>,
+			              "lpmLookupAddress cannot be used with types other than ipv4/6_address");
 		}
-	}
-}
+	}();
 
-void lpm6LookupAddress(const common::ipv6_address_t& ipv6Address)
-{
-	interface::dataPlane dataPlane;
-	const auto response = dataPlane.lpm6LookupAddress(ipv6Address);
-	for (const auto& iter : response)
+	for (const auto& [socketId, entry] : response)
 	{
-		const auto& socketId = iter.first;
-		const auto& found = std::get<0>(iter.second);
-		const auto& valueId = std::get<1>(iter.second);
-		const auto& value = std::get<2>(iter.second);
+		const auto& [found, valueId, value] = entry;
+		std::cout << "[socketId: " << socketId << "] " << address.toString() << " -> ";
 
-		printf("[socketId: %u] %s -> ", socketId, common::ipv6_address_t(ipv6Address).toString().data());
 		if (found)
 		{
-			printf("valueId: %u\n", valueId);
+			std::cout << "valueId: " << valueId << '\n';
 			printValue(value);
 		}
 		else
 		{
-			printf("not found\n");
+			std::cout << "not found\n";
 		}
 	}
 }
 
-void getErrors()
+inline void lpm4LookupAddress(const common::ipv4_address_t& address)
+{
+	lpmLookupAddress(address);
+}
+
+inline void lpm6LookupAddress(const common::ipv6_address_t& address)
+{
+	lpmLookupAddress(address);
+}
+
+inline void getErrors()
 {
 	interface::dataPlane dataPlane;
-	const auto response = dataPlane.getErrors();
 
-	printf("errors:\n");
-	for (const auto& iter : response)
+	std::cout << "errors:\n";
+	for (const auto& [name, counter] : dataPlane.getErrors())
 	{
-		printf("  (%lu) %s\n",
-		       iter.second.value,
-		       iter.first.data());
+		std::cout << "  (" << counter.value << ") " << name << '\n';
 	}
 }
 
-void getReport()
+inline void getReport()
 {
 	interface::dataPlane dataPlane;
-	const auto response = dataPlane.getReport();
-	printf("%s\n", response.data());
+	std::cout << dataPlane.getReport() << '\n';
 }
 
-void counter(const uint32_t& counter_id,
-             const std::optional<uint32_t>& range_size)
+inline void counter(uint32_t counter_id, const std::optional<uint32_t>& range_size)
 {
-	interface::dataPlane dataplane;
+	std::vector<tCounterId> counter_ids{counter_id};
 
-	std::vector<tCounterId> counter_ids = {counter_id};
-	if (range_size && (*range_size) > 0)
+	if (range_size.has_value() && range_size.value() > 0)
 	{
-		for (uint32_t offset = 0;
-		     offset < (*range_size) - 1;
-		     offset++)
+		for (uint32_t offset = 0; offset < range_size.value() - 1; offset++)
 		{
 			counter_ids.emplace_back(counter_id + offset + 1);
 		}
 	}
 
-	const auto response = common::sdp::SdpClient::GetCounters(counter_ids);
+	const auto& response = common::sdp::SdpClient::GetCounters(counter_ids);
 
-	table_t table;
-	table.insert("counter_id",
-	             "value");
+	TablePrinter table;
+	table.insert("counter_id", "value");
 
-	for (uint32_t i = 0;
-	     i < counter_ids.size();
-	     i++)
+	for (uint32_t i = 0; i < counter_ids.size(); i++)
 	{
-		table.insert(counter_ids[i],
-		             response[i]);
+		table.insert_row(counter_ids[i], response[i]);
 	}
 
-	table.print();
+	table.Print();
 }
 
 using namespace ::dataplane::perf;
-class tsc_monitoring_t
+struct tsc_monitoring_t
 {
-public:
 	void connect_shm()
 	{
 		interface::dataPlane dataplane;
-		const auto response = dataplane.get_shm_tsc_info();
+		const auto& response = dataplane.get_shm_tsc_info();
 		std::map<key_t, void*> ipc_cache;
 
 		for (const auto& [core, socket, ipc_key, offset] : response)
 		{
-			(void)socket;
+			YANET_GCC_BUG_UNUSED(socket);
 			if (ipc_cache.find(ipc_key) == ipc_cache.end())
 			{
-				auto shmid = shmget(ipc_key, 0, 0);
-				if (shmid == -1)
-				{
-					throw std::string("shmget(") + std::to_string(ipc_key) + ", 0, 0) = " + std::strerror(errno);
-				}
-				auto shmaddr = shmat(shmid, NULL, SHM_RDONLY);
-				if (shmaddr == (void*)-1)
+				auto&& [shmaddr, size] = common::ipc::SharedMemory::OpenBufferKey(ipc_key, false);
+				YANET_GCC_BUG_UNUSED(size);
+
+				if (shmaddr == nullptr)
 				{
-					throw std::string("shmat(") + std::to_string(ipc_key) + ", NULL, 0) = " + std::strerror(errno);
+					throw std::system_error(errno, std::generic_category(), "Opening an existing buffer in shared memory failed");
 				}
 
 				ipc_cache[ipc_key] = shmaddr;
 			}
 
-			auto counter_addr = (tsc_deltas*)((intptr_t)ipc_cache[ipc_key] + offset);
+			auto counter_addr = reinterpret_cast<tsc_deltas*>(
+			        reinterpret_cast<intptr_t>(ipc_cache[ipc_key]) + offset);
 			worker_counters.emplace_back(core, counter_addr, tsc_deltas{}, overflow_store{});
 		}
 	}
@@ -206,9 +193,13 @@ class tsc_monitoring_t
 	void monitor()
 	{
 		connect_shm();
-		for (auto iter = 0;; iter++)
+		const int header_interval = 4;
+
+		for (int iter = 0;; ++iter)
 		{
-			if (iter % 4 == 0)
+			bool render_header = (iter % header_interval == 0);
+
+			if (render_header)
 			{
 				insert_header();
 			}
@@ -216,10 +207,11 @@ class tsc_monitoring_t
 			for (auto& [core_id, counter, previous_value, overflow_store] : worker_counters)
 			{
 				const auto& counter_copy = *counter;
-				for (auto bin = 0; bin < YANET_TSC_BINS_N; bin++)
+				for (int bin = 0; bin < YANET_TSC_BINS_N; ++bin)
 				{
 					overflow_store.handle_overflow(counter_copy, previous_value, bin);
-					if (iter % 4 == 0)
+
+					if (render_header)
 					{
 						insert_bin(counter_copy, overflow_store, bin, core_id);
 					}
@@ -228,145 +220,157 @@ class tsc_monitoring_t
 				previous_value = counter_copy;
 			}
 
-			if (iter % 4 == 0)
+			if (render_header)
 			{
-				table.render();
+				table.Render();
 			}
+
 			std::this_thread::sleep_for(std::chrono::milliseconds(250));
 		}
 	}
 
-protected:
-	struct overflow_store;
-
-	void insert_header()
+private:
+	struct overflow_store
 	{
-		table.insert("core_id",
-		             "iter_num",
-		             "logicalPort_ingress",
-		             "acl_ingress4",
-		             "acl_ingress6",
-		             "tun64_ipv4",
-		             "tun64_ipv6",
-		             "route4",
-		             "route6",
-		             "decap",
-		             "nat64stateful_lan",
-		             "nat64stateful_wan",
-		             "nat64stateless_egress",
-		             "nat64stateless_ingress",
-		             "nat46clat_lan",
-		             "nat46clat_wan",
-		             "balancer",
-		             "balancer_icmp_reply",
-		             "balancer_icmp_forward",
-		             "route_tunnel4",
-		             "route_tunnel6",
-		             "acl_egress4",
-		             "acl_egress6",
-		             "logicalPort_egress",
-		             "controlPlane");
-	}
+		template<typename T>
+		static auto make_tuple(T& obj)
+		{
+			return std::tie(obj.logicalPort_ingress_handle,
+			                obj.acl_ingress_handle4,
+			                obj.acl_ingress_handle6,
+			                obj.tun64_ipv4_handle,
+			                obj.tun64_ipv6_handle,
+			                obj.route_handle4,
+			                obj.route_handle6,
+			                obj.decap_handle,
+			                obj.nat64stateful_lan_handle,
+			                obj.nat64stateful_wan_handle,
+			                obj.nat64stateless_egress_handle,
+			                obj.nat64stateless_ingress_handle,
+			                obj.nat46clat_lan_handle,
+			                obj.nat46clat_wan_handle,
+			                obj.balancer_handle,
+			                obj.balancer_icmp_reply_handle,
+			                obj.balancer_icmp_forward_handle,
+			                obj.route_tunnel_handle4,
+			                obj.route_tunnel_handle6,
+			                obj.acl_egress_handle4,
+			                obj.acl_egress_handle6,
+			                obj.logicalPort_egress_handle,
+			                obj.controlPlane_handle);
+		}
 
-	void insert_bin(const tsc_deltas& cnt, const overflow_store& of_store, int bin, uint32_t core_id)
-	{
-		table.insert(bin == 0 ? std::to_string(core_id) : std::string{},
-		             bin == 0 ? std::to_string(cnt.iter_num) : std::string{},
-		             of_store.logicalPort_ingress_handle[bin] + cnt.logicalPort_ingress_handle[bin],
-		             of_store.acl_ingress_handle4[bin] + cnt.acl_ingress_handle4[bin],
-		             of_store.acl_ingress_handle6[bin] + cnt.acl_ingress_handle6[bin],
-		             of_store.tun64_ipv4_handle[bin] + cnt.tun64_ipv4_handle[bin],
-		             of_store.tun64_ipv6_handle[bin] + cnt.tun64_ipv6_handle[bin],
-		             of_store.route_handle4[bin] + cnt.route_handle4[bin],
-		             of_store.route_handle6[bin] + cnt.route_handle6[bin],
-
-		             of_store.decap_handle[bin] + cnt.decap_handle[bin],
-		             of_store.nat64stateful_lan_handle[bin] + cnt.nat64stateful_lan_handle[bin],
-		             of_store.nat64stateful_wan_handle[bin] + cnt.nat64stateful_wan_handle[bin],
-		             of_store.nat64stateless_egress_handle[bin] + cnt.nat64stateless_egress_handle[bin],
-		             of_store.nat64stateless_ingress_handle[bin] + cnt.nat64stateless_ingress_handle[bin],
-		             of_store.nat46clat_lan_handle[bin] + cnt.nat46clat_lan_handle[bin],
-		             of_store.nat46clat_wan_handle[bin] + cnt.nat46clat_wan_handle[bin],
-		             of_store.balancer_handle[bin] + cnt.balancer_handle[bin],
-
-		             of_store.balancer_icmp_reply_handle[bin] + cnt.balancer_icmp_reply_handle[bin],
-		             of_store.balancer_icmp_forward_handle[bin] + cnt.balancer_icmp_forward_handle[bin],
-		             of_store.route_tunnel_handle4[bin] + cnt.route_tunnel_handle4[bin],
-		             of_store.route_tunnel_handle6[bin] + cnt.route_tunnel_handle6[bin],
-		             of_store.acl_egress_handle4[bin] + cnt.acl_egress_handle4[bin],
-		             of_store.acl_egress_handle6[bin] + cnt.acl_egress_handle6[bin],
-		             of_store.logicalPort_egress_handle[bin] + cnt.logicalPort_egress_handle[bin],
-		             of_store.controlPlane_handle[bin] + cnt.controlPlane_handle[bin]);
-	}
+		using CountersArray = std::array<uint64_t, YANET_TSC_BINS_N>;
+
+		CountersArray logicalPort_ingress_handle{};
+		CountersArray acl_ingress_handle4{};
+		CountersArray acl_ingress_handle6{};
+		CountersArray tun64_ipv4_handle{};
+		CountersArray tun64_ipv6_handle{};
+		CountersArray route_handle4{};
+		CountersArray route_handle6{};
+
+		CountersArray decap_handle{};
+		CountersArray nat64stateful_lan_handle{};
+		CountersArray nat64stateful_wan_handle{};
+		CountersArray nat64stateless_egress_handle{};
+		CountersArray nat64stateless_ingress_handle{};
+		CountersArray nat46clat_lan_handle{};
+		CountersArray nat46clat_wan_handle{};
+		CountersArray balancer_handle{};
+
+		CountersArray balancer_icmp_reply_handle{};
+		CountersArray balancer_icmp_forward_handle{};
+		CountersArray route_tunnel_handle4{};
+		CountersArray route_tunnel_handle6{};
+		CountersArray acl_egress_handle4{};
+		CountersArray acl_egress_handle6{};
+		CountersArray logicalPort_egress_handle{};
+		CountersArray controlPlane_handle{};
+
+		auto as_tuple()
+		{
+			return make_tuple(*this);
+		}
 
-	struct overflow_store
-	{
-		uint64_t logicalPort_ingress_handle[YANET_TSC_BINS_N];
-		uint64_t acl_ingress_handle4[YANET_TSC_BINS_N];
-		uint64_t acl_ingress_handle6[YANET_TSC_BINS_N];
-		uint64_t tun64_ipv4_handle[YANET_TSC_BINS_N];
-		uint64_t tun64_ipv6_handle[YANET_TSC_BINS_N];
-		uint64_t route_handle4[YANET_TSC_BINS_N];
-		uint64_t route_handle6[YANET_TSC_BINS_N];
-
-		uint64_t decap_handle[YANET_TSC_BINS_N];
-		uint64_t nat64stateful_lan_handle[YANET_TSC_BINS_N];
-		uint64_t nat64stateful_wan_handle[YANET_TSC_BINS_N];
-		uint64_t nat64stateless_egress_handle[YANET_TSC_BINS_N];
-		uint64_t nat64stateless_ingress_handle[YANET_TSC_BINS_N];
-		uint64_t nat46clat_lan_handle[YANET_TSC_BINS_N];
-		uint64_t nat46clat_wan_handle[YANET_TSC_BINS_N];
-		uint64_t balancer_handle[YANET_TSC_BINS_N];
-
-		uint64_t balancer_icmp_reply_handle[YANET_TSC_BINS_N];
-		uint64_t balancer_icmp_forward_handle[YANET_TSC_BINS_N];
-		uint64_t route_tunnel_handle4[YANET_TSC_BINS_N];
-		uint64_t route_tunnel_handle6[YANET_TSC_BINS_N];
-		uint64_t acl_egress_handle4[YANET_TSC_BINS_N];
-		uint64_t acl_egress_handle6[YANET_TSC_BINS_N];
-		uint64_t logicalPort_egress_handle[YANET_TSC_BINS_N];
-		uint64_t controlPlane_handle[YANET_TSC_BINS_N];
+		[[nodiscard]] auto as_tuple() const
+		{
+			return make_tuple(*this);
+		}
 
 		void handle_overflow(const tsc_deltas& cnt, const tsc_deltas& prev, int bin)
 		{
-			logicalPort_ingress_handle[bin] += (prev.logicalPort_ingress_handle[bin] > cnt.logicalPort_ingress_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			acl_ingress_handle4[bin] += (prev.acl_ingress_handle4[bin] > cnt.acl_ingress_handle4[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			acl_ingress_handle6[bin] += (prev.acl_ingress_handle6[bin] > cnt.acl_ingress_handle6[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			tun64_ipv4_handle[bin] += (prev.tun64_ipv4_handle[bin] > cnt.tun64_ipv4_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			tun64_ipv6_handle[bin] += (prev.tun64_ipv6_handle[bin] > cnt.tun64_ipv6_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			route_handle4[bin] += (prev.route_handle4[bin] > cnt.route_handle4[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			route_handle6[bin] += (prev.route_handle6[bin] > cnt.route_handle6[bin]) << sizeof(uint16_t) * CHAR_BIT;
-
-			decap_handle[bin] += (prev.decap_handle[bin] > cnt.decap_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			nat64stateful_lan_handle[bin] += (prev.nat64stateful_lan_handle[bin] > cnt.nat64stateful_lan_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			nat64stateful_wan_handle[bin] += (prev.nat64stateful_wan_handle[bin] > cnt.nat64stateful_wan_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			nat64stateless_egress_handle[bin] += (prev.nat64stateless_egress_handle[bin] > cnt.nat64stateless_egress_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			nat64stateless_ingress_handle[bin] += (prev.nat64stateless_ingress_handle[bin] > cnt.nat64stateless_ingress_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			nat46clat_lan_handle[bin] += (prev.nat46clat_lan_handle[bin] > cnt.nat46clat_lan_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			nat46clat_wan_handle[bin] += (prev.nat46clat_wan_handle[bin] > cnt.nat46clat_wan_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			balancer_handle[bin] += (prev.balancer_handle[bin] > cnt.balancer_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-
-			balancer_icmp_reply_handle[bin] += (prev.balancer_icmp_reply_handle[bin] > cnt.balancer_icmp_reply_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			balancer_icmp_forward_handle[bin] += (prev.balancer_icmp_forward_handle[bin] > cnt.balancer_icmp_forward_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			route_tunnel_handle4[bin] += (prev.route_tunnel_handle4[bin] > cnt.route_tunnel_handle4[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			route_tunnel_handle6[bin] += (prev.route_tunnel_handle6[bin] > cnt.route_tunnel_handle6[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			acl_egress_handle4[bin] += (prev.acl_egress_handle4[bin] > cnt.acl_egress_handle4[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			acl_egress_handle6[bin] += (prev.acl_egress_handle6[bin] > cnt.acl_egress_handle6[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			logicalPort_egress_handle[bin] += (prev.logicalPort_egress_handle[bin] > cnt.logicalPort_egress_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
-			controlPlane_handle[bin] += (prev.controlPlane_handle[bin] > cnt.controlPlane_handle[bin]) << sizeof(uint16_t) * CHAR_BIT;
+			auto this_tuple = as_tuple();
+			auto cnt_tuple = cnt.as_tuple();
+			auto prev_tuple = prev.as_tuple();
+
+			auto op = [&](auto& this_member, const auto& cnt_member, const auto& prev_member) {
+				this_member[bin] += (prev_member[bin] > cnt_member[bin]) << (sizeof(uint16_t) * CHAR_BIT);
+			};
+
+			utils::zip_apply(op, this_tuple, cnt_tuple, prev_tuple);
 		}
 	};
 
 	std::vector<std::tuple<uint32_t, tsc_deltas*, tsc_deltas, overflow_store>> worker_counters;
-	table_t table;
+	TablePrinter table;
+
+	void insert_header()
+	{
+		table.insert_row("core_id",
+		                 "iter_num",
+		                 "logicalPort_ingress",
+		                 "acl_ingress4",
+		                 "acl_ingress6",
+		                 "tun64_ipv4",
+		                 "tun64_ipv6",
+		                 "route4",
+		                 "route6",
+		                 "decap",
+		                 "nat64stateful_lan",
+		                 "nat64stateful_wan",
+		                 "nat64stateless_egress",
+		                 "nat64stateless_ingress",
+		                 "nat46clat_lan",
+		                 "nat46clat_wan",
+		                 "balancer",
+		                 "balancer_icmp_reply",
+		                 "balancer_icmp_forward",
+		                 "route_tunnel4",
+		                 "route_tunnel6",
+		                 "acl_egress4",
+		                 "acl_egress6",
+		                 "logicalPort_egress",
+		                 "controlPlane");
+	}
+
+	void insert_bin(const tsc_deltas& cnt, const overflow_store& of_store, int bin, uint32_t core_id)
+	{
+		constexpr std::size_t tuple_size = std::tuple_size_v<decltype(cnt.as_tuple())>;
+		// The total size of the row will be 2 fixed elements (core_id and iter_num) plus tuple_size
+		std::array<std::string, 2 + tuple_size> row;
+
+		row[0] = (bin == 0) ? std::to_string(core_id) : std::string{};
+		row[1] = (bin == 0) ? std::to_string(cnt.iter_num) : std::string{};
+
+		auto cnt_tuple = cnt.as_tuple();
+		auto of_store_tuple = of_store.as_tuple();
+
+		std::size_t index = 2; // Start after core_id and iter_num
+		auto op = [&](const auto& of_store_member, const auto& cnt_member) mutable {
+			row[index++] = std::to_string(of_store_member[bin] + cnt_member[bin]);
+		};
+
+		utils::zip_apply(op, of_store_tuple, cnt_tuple);
+
+		table.insert_row(row.begin(), row.end());
+	}
 };
 
-void tsc_monitoring()
+inline void tsc_monitoring()
 {
 	tsc_monitoring_t monitoring{};
 	monitoring.monitor();
 }
 
 }
-
-}
diff --git a/cli/dregress.h b/cli/dregress.h
index e97b659b..2aa2727e 100644
--- a/cli/dregress.h
+++ b/cli/dregress.h
@@ -2,7 +2,7 @@
 
 #include "common/icontrolplane.h"
 
-#include "helper.h"
+#include "table_printer.h"
 
 namespace dregress
 {
@@ -12,29 +12,29 @@ void summary()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.dregress_config();
 
-	table_t table;
-	table.insert("module",
-	             "ipv6_sources",
-	             "ipv6_destination",
-	             "ipv4_address",
-	             "ipv6_address",
-	             "udp_destination_port",
-	             "only_longest",
-	             "next_module");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "ipv6_sources",
+	                 "ipv6_destination",
+	                 "ipv4_address",
+	                 "ipv6_address",
+	                 "udp_destination_port",
+	                 "only_longest",
+	                 "next_module");
 
 	for (const auto& [module_name, dregress] : response)
 	{
-		table.insert(module_name,
-		             dregress.ipv6SourcePrefixes,
-		             dregress.ipv6DestinationPrefix,
-		             dregress.ipv4SourceAddress,
-		             dregress.ipv6SourceAddress,
-		             dregress.udpDestinationPort,
-		             dregress.onlyLongest,
-		             dregress.nextModule);
+		table.insert_row(module_name,
+		                 dregress.ipv6SourcePrefixes,
+		                 dregress.ipv6DestinationPrefix,
+		                 dregress.ipv4SourceAddress,
+		                 dregress.ipv6SourceAddress,
+		                 dregress.udpDestinationPort,
+		                 dregress.onlyLongest,
+		                 dregress.nextModule);
 	}
 
-	table.print();
+	table.Print();
 }
 
 void announce()
@@ -42,17 +42,17 @@ void announce()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.dregress_config();
 
-	table_t table;
+	TablePrinter table;
 	table.insert("module",
 	             "announces");
 
 	for (const auto& [module_name, dregress] : response)
 	{
-		table.insert(module_name,
-		             dregress.announces);
+		table.insert_row(module_name,
+		                 dregress.announces);
 	}
 
-	table.print();
+	table.Print();
 }
 
 /** @todo
diff --git a/cli/helper.h b/cli/helper.h
index 4d4ceea6..7e9ba0db 100644
--- a/cli/helper.h
+++ b/cli/helper.h
@@ -1,474 +1,100 @@
 #pragma once
 
-#include <array>
 #include <cstdio>
-#include <iomanip>
-#include <map>
-#include <sstream>
 #include <string>
 #include <tuple>
 #include <type_traits>
 #include <vector>
 
-#include <nlohmann/json.hpp>
-
 #include "common/sdpclient.h"
-#include "converter.h"
+#include "common/traits.h"
+#include "table_printer.h"
 
-template<typename type>
-static std::string to_percent(const type current, const type maximum)
-{
-	double percent = 0.0;
-	if (maximum)
-	{
-		percent = (double)current / (double)maximum;
-		percent *= (double)100;
-	}
+#if __cpp_lib_charconv >= 201606L && !defined(__GNUC__) || __GNUC__ >= 8
+#define USE_FROM_CHARS
+#endif
 
-	std::stringstream stream;
-	stream << std::fixed << std::setprecision(2) << percent;
-	return stream.str();
-}
-
-std::vector<std::string> split(const char* string,
-                               const char delimiter)
-{
-	std::vector<std::string> result;
-	std::stringstream ss(string);
-
-	std::string part;
-	while (std::getline(ss, part, delimiter))
-	{
-		result.emplace_back(part);
-	}
-
-	return result;
-}
-
-void fillValue(std::optional<uint8_t>& value, const std::string& string)
-{
-	if (string == "any")
-	{
-		value = std::nullopt;
-	}
-	else if (string != "")
-	{
-		value = std::stoull(string, nullptr, 0);
-		;
-	}
-	else
-	{
-		value = std::nullopt;
-	}
-}
-
-void fillValue(std::optional<uint16_t>& value, const std::string& string)
-{
-	if (string == "any")
-	{
-		value = std::nullopt;
-	}
-	else if (string != "")
-	{
-		value = std::stoull(string, nullptr, 0);
-		;
-	}
-	else
-	{
-		value = std::nullopt;
-	}
-}
-
-void fillValue(std::optional<uint32_t>& value, const std::string& string)
-{
-	if (string == "any")
-	{
-		value = std::nullopt;
-	}
-	else if (string != "")
-	{
-		value = std::stoull(string, nullptr, 0);
-		;
-	}
-	else
-	{
-		value = std::nullopt;
-	}
-}
-
-template<typename TArg>
-void fillValue(std::optional<TArg>& value, const std::string& string)
-{
-	if (string == "any")
-	{
-		value = std::nullopt;
-	}
-	else if (string != "")
-	{
-		value = string;
-	}
-	else
-	{
-		value = std::nullopt;
-	}
-}
+#if defined(USE_FROM_CHARS)
+#include <charconv>
+#else
+#include <sstream>
+#endif
 
-void fillValue(bool& value, const std::string& string)
+template<typename T>
+static void fill(T& value, const std::string& str)
 {
-	if (string == "false" || string == "true")
+	if constexpr (std::is_same_v<T, bool>)
 	{
-		value = string == "true";
+		if (str == "true")
+			value = true;
+		else if (str == "false")
+			value = false;
+		else
+			throw std::invalid_argument("Invalid boolean value");
 	}
-	else
+	else if constexpr (std::is_integral_v<T> || std::is_floating_point_v<T>)
 	{
-		throw std::string("invalid argument, must be true or false");
+#ifdef USE_FROM_CHARS
+		auto [ptr, ec] = std::from_chars(str.data(), str.data() + str.size(), value);
+		if (ec != std::errc{})
+			throw std::invalid_argument("Invalid numeric value: '" + str + "'");
+#else
+		std::istringstream iss(str);
+		if (!(iss >> value) || !iss.eof())
+			throw std::invalid_argument("Invalid numeric value: '" + str + "'");
+#endif
 	}
-}
-
-void fillValue(uint8_t& value, const std::string& string)
-{
-	value = std::stoull(string, nullptr, 0);
-}
-
-void fillValue(uint16_t& value, const std::string& string)
-{
-	value = std::stoull(string, nullptr, 0);
-}
-
-void fillValue(uint32_t& value, const std::string& string)
-{
-	value = std::stoull(string, nullptr, 0);
-}
-
-template<typename TArg>
-void fillValue(TArg& value, const std::string& string)
-{
-	value = string;
-}
-
-template<typename TArg>
-void fillValue(std::optional<TArg>& value)
-{
-	value = std::nullopt;
-}
-
-template<typename TArg>
-void fillValue(TArg& value)
-{
-	(void)value;
-	throw std::string("invalid arguments count");
-}
-
-template<size_t TIndex,
-         size_t TSize,
-         typename TTuple>
-void fillTuple(TTuple& tuple, const std::vector<std::string>& stringArgs)
-{
-	if constexpr (TIndex < TSize)
+	else if constexpr (traits::is_optional_v<T>)
 	{
-		if (TIndex < stringArgs.size())
+		if (str == "any" || str.empty())
 		{
-			fillValue(std::get<TIndex>(tuple), stringArgs[TIndex]);
+			value.reset();
 		}
 		else
 		{
-			fillValue(std::get<TIndex>(tuple));
+			typename T::value_type temp;
+			fill(temp, str);
+			value = std::move(temp);
 		}
-
-		fillTuple<TIndex + 1, TSize>(tuple, stringArgs);
 	}
-}
-
-template<typename... TArgs>
-void call(void (*func)(TArgs... args),
-          const std::vector<std::string>& stringArgs)
-{
-	if (stringArgs.size() > sizeof...(TArgs))
+	else
 	{
-		throw std::string("invalid arguments count: '") + std::to_string(stringArgs.size()) + "', need: '" + std::to_string(sizeof...(TArgs)) + "'";
+		value = str;
 	}
-	std::tuple<std::decay_t<TArgs>...> tuple;
-	fillTuple<0, sizeof...(TArgs)>(tuple, stringArgs);
-	std::apply(func, tuple);
 }
 
-template<size_t TIndex,
-         size_t TSize,
-         typename TDiffTuple,
-         typename TTuple>
-void getDiffTuple(TDiffTuple& diff,
-                  const TTuple& curr,
-                  const TTuple& prev)
+// Fill a tuple with values from a vector of strings
+template<typename Tuple, std::size_t... Is>
+static void fillTupleImpl(Tuple& tuple, const std::vector<std::string>& args, std::index_sequence<Is...>)
 {
-	if constexpr (TIndex < TSize)
-	{
-		std::get<TIndex>(diff) = std::get<TIndex>(curr) - std::get<TIndex>(prev);
-		getDiffTuple<TIndex + 1, TSize>(diff, curr, prev);
-	}
+	(..., fill(std::get<Is>(tuple), Is < args.size() ? args[Is] : std::string{}));
 }
 
-template<typename TFirst,
-         typename... TSecondArgs>
-std::map<TFirst, std::array<int64_t, sizeof...(TSecondArgs)>> getDiff(const std::map<TFirst, std::tuple<TSecondArgs...>>& curr,
-                                                                      const std::map<TFirst, std::tuple<TSecondArgs...>>& prev)
+template<typename... Args>
+static void fillTuple(std::tuple<Args...>& tuple, const std::vector<std::string>& args)
 {
-	std::map<TFirst, std::array<int64_t, sizeof...(TSecondArgs)>> result;
-
-	for (const auto& iter : curr)
-	{
-		if (prev.find(iter.first) != prev.end())
-		{
-			std::array<int64_t, sizeof...(TSecondArgs)> diff;
-			getDiffTuple<0, sizeof...(TSecondArgs)>(diff, iter.second, prev.find(iter.first)->second);
-			result[iter.first] = diff;
-		}
-	}
-
-	return result;
+	fillTupleImpl(tuple, args, std::index_sequence_for<Args...>{});
 }
 
-class table_t
+// Call function using string arguments
+template<typename F>
+inline void Call(F&& func, const std::vector<std::string>& string_args)
 {
-public:
-	table_t(const converter::config_t config = {}) :
-	        config(config)
-	{
-	}
+	using ArgsTuple = typename traits::function<F>::args;
+	constexpr auto arity = std::tuple_size_v<ArgsTuple>;
 
-	template<typename... args_T>
-	void insert(const args_T&... args)
+	if (string_args.size() > arity)
 	{
-		std::vector<std::string> row = {converter::to_string(args, config)...};
-
-		if (row.size() > columnLengths.size())
-		{
-			columnLengths.resize(row.size(), 0);
-		}
-
-		for (uint32_t string_i = 0;
-		     string_i < row.size();
-		     string_i++)
-		{
-			if (columnLengths[string_i] < row[string_i].size())
-			{
-				columnLengths[string_i] = row[string_i].size();
-			}
-		}
-
-		table.emplace_back(row);
+		throw std::invalid_argument("Invalid arguments count: '" + std::to_string(string_args.size()) +
+		                            "', expected at most: '" + std::to_string(arity) + "'");
 	}
 
-	void print_json()
-	{
-		std::vector<std::string> format_keys;
-		std::map<unsigned int, unsigned int> format_keys_i;
-		if (const char* format_keys_pointer = std::getenv("YANET_FORMAT_KEYS"))
-		{
-			format_keys = split(format_keys_pointer, ',');
-		}
-
-		std::vector<std::string> keys;
-
-		bool header = true;
-		nlohmann::json json_root;
-		for (auto& row : table)
-		{
-			if (header)
-			{
-				for (uint32_t string_i = 0;
-				     string_i < row.size();
-				     string_i++)
-				{
-					for (uint32_t format_i = 0;
-					     format_i < format_keys.size();
-					     format_i++)
-					{
-						if (row[string_i] == format_keys[format_i])
-						{
-							format_keys_i[string_i] = format_i;
-						}
-					}
-				}
-
-				keys = row;
-				header = false;
-				continue;
-			}
-
-			std::vector<std::string> tree;
-			tree.resize(format_keys.size());
-
-			nlohmann::json json_row;
-			for (uint32_t string_i = 0;
-			     string_i < row.size();
-			     string_i++)
-			{
-				if (format_keys_i.count(string_i))
-				{
-					tree[format_keys_i[string_i]] = row[string_i];
-				}
-				else
-				{
-					json_row[keys[string_i]] = row[string_i];
-				}
-			}
-
-			auto* json_current = &json_root;
-			for (const auto& key : tree)
-			{
-				json_current = &((*json_current)[key]);
-			}
-			(*json_current).emplace_back(json_row);
-		}
-
-		printf("%s\n", json_root.dump(2).data());
-	}
-
-	void print_default()
-	{
-		if (table.size() == 0 ||
-		    columnLengths.size() == 0)
-		{
-			return;
-		}
-
-		std::vector<std::string> user_selected_col_names;
-		bool print_selected_cols_only = false;
-		if (const char* columns_pointer = std::getenv("YANET_FORMAT_COLUMNS"))
-		{
-			user_selected_col_names = split(columns_pointer, ',');
-			print_selected_cols_only = true;
-		}
-
-		/* header row contains table's column names */
-		auto& header_row = table[0];
-
-		/* If the user listed only specific columns of the table to be printed in specific order,
-		   need to build a relation between index of column in user-provided order and its index in the table (only if it does exist in the table):
-		   This relation: columns_order[col_idx_in_user_selection] = col_idx_in_table
-
-		   Otherwise, when no custom columns' selection and/or order is provided by the user,
-		   print all columns of the table in the table's order:
-		   columns_order[col_idx_in_table] = col_idx_in_table */
-		std::vector<uint32_t> columns_order;
-		if (print_selected_cols_only)
-		{
-			uint32_t col_idx_in_user_selection = 0;
-			while (columns_order.size() < user_selected_col_names.size())
-			{
-				bool selected_col_name_found = false;
-				for (uint32_t col_idx_in_table = 0; col_idx_in_table < header_row.size(); ++col_idx_in_table)
-				{
-					if (user_selected_col_names[col_idx_in_user_selection] == header_row[col_idx_in_table])
-					{
-						// col_idx_in_user_selection must be equal to columns_order.size() prior to insertion (check?)
-						columns_order.push_back(col_idx_in_table);
-						selected_col_name_found = true;
-						++col_idx_in_user_selection;
-						break;
-					}
-				}
-
-				if (!selected_col_name_found)
-				{
-					// evidently, user provided such a column name, which does not exist in the table, cannot print it
-					// shifting tail of user_selected_col_names to the left by erasing non-existent user-provided column name
-					user_selected_col_names.erase(user_selected_col_names.begin() + col_idx_in_user_selection);
-				}
-			}
-		}
-		else
-		{
-			columns_order.resize(header_row.size());
-			std::iota(columns_order.begin(), columns_order.end(), 0);
-		}
-
-		if (columns_order.size() == 0)
-		{
-			/* column names provided by user do not match any column names of the table,
-			   or the table does not have any columns at all (what?!) */
-			return;
-		}
-
-		bool header = true;
-		for (auto& row : table)
-		{
-			printf("%-*s",
-			       columnLengths[columns_order[0]],
-			       row[columns_order[0]].data());
-
-			for (uint32_t string_i = 1;
-			     string_i < columns_order.size();
-			     string_i++)
-			{
-				if (string_i != columns_order.size() - 1)
-				{
-					printf("  %-*s",
-					       columnLengths[columns_order[string_i]],
-					       row[columns_order[string_i]].data());
-				}
-				else
-				{
-					// Do not explode the last column with padding whitespace bytes.
-					printf("  %s",
-					       row[columns_order[string_i]].data());
-				}
-			}
-
-			printf("\n");
-
-			if (header)
-			{
-				printf("%s", std::string(columnLengths[columns_order[0]], '-').data());
-
-				for (uint32_t string_i = 1;
-				     string_i < columns_order.size();
-				     string_i++)
-				{
-					printf("  %s", std::string(columnLengths[columns_order[string_i]], '-').data());
-				}
-
-				printf("\n");
-
-				header = false;
-			}
-		}
-	}
-
-	void print()
-	{
-		std::string format;
-		if (const char* format_pointer = std::getenv("YANET_FORMAT"))
-		{
-			format = format_pointer;
-		}
-
-		if (format == "json")
-		{
-			print_json();
-		}
-		else
-		{
-			print_default();
-		}
-	}
-
-	void render()
-	{
-		printf("\033[H\033[2J");
-		fflush(stdout);
-
-		print_default();
-		table.clear();
-	}
-
-protected:
-	converter::config_t config;
-	std::vector<std::vector<std::string>> table;
-	std::vector<uint32_t> columnLengths;
-};
+	utils::decay_tuple<ArgsTuple> args_tuple;
+	fillTuple(args_tuple, string_args);
+	std::apply(std::forward<F>(func), args_tuple);
+}
 
-void OpenSharedMemoryDataplaneBuffers(common::sdp::DataPlaneInSharedMemory& sdp_data, bool open_workers_data)
+inline void OpenSharedMemoryDataplaneBuffers(common::sdp::DataPlaneInSharedMemory& sdp_data, bool open_workers_data)
 {
 	if (common::sdp::SdpClient::ReadSharedMemoryData(sdp_data, open_workers_data) != eResult::success)
 	{
@@ -476,3 +102,13 @@ void OpenSharedMemoryDataplaneBuffers(common::sdp::DataPlaneInSharedMemory& sdp_
 		std::exit(1);
 	}
 }
+
+template<typename Container>
+inline void FillAndPrintTable(const std::initializer_list<std::string_view>& headers, const Container& data, const converter::config_t config = {})
+{
+	TablePrinter table(config);
+
+	table.insert_row(headers.begin(), headers.end());
+	table.insert(data.begin(), data.end());
+	table.Print();
+}
diff --git a/cli/influxdb_format.h b/cli/influxdb_format.h
index ff95b706..544fec6b 100644
--- a/cli/influxdb_format.h
+++ b/cli/influxdb_format.h
@@ -88,11 +88,9 @@ std::string to_string(const char* key,
 class base_t
 {
 public:
-	virtual ~base_t()
-	{
-	}
+	virtual ~base_t() = default;
 
-	const std::string& to_string() const
+	[[nodiscard]] const std::string& to_string() const
 	{
 		return string;
 	}
@@ -183,7 +181,7 @@ void print_histogram(const char* name,
                      const index_T start,
                      const index_T end)
 {
-	for (unsigned int i = (unsigned int)start;
+	for (auto i = (unsigned int)start;
 	     i <= (unsigned int)end;
 	     i++)
 	{
diff --git a/cli/latch.h b/cli/latch.h
index 1302378c..841ed303 100644
--- a/cli/latch.h
+++ b/cli/latch.h
@@ -1,7 +1,10 @@
 #pragma once
 
+#include "common/idataplane.h"
+#include "common/idp.h"
 #include <cstdint>
 #include <cstring>
+#include <string>
 
 namespace latch
 {
diff --git a/cli/limit.h b/cli/limit.h
index 13f60db7..437c9976 100644
--- a/cli/limit.h
+++ b/cli/limit.h
@@ -1,10 +1,9 @@
 #pragma once
 
-#include <iomanip>
-
 #include "common/icontrolplane.h"
 
-#include "helper.h"
+#include "common/utils.h"
+#include "table_printer.h"
 
 namespace limit
 {
@@ -14,34 +13,14 @@ void summary()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.limit_summary();
 
-	table_t table;
-	table.insert("name",
-	             "socket_id",
-	             "current",
-	             "maximum",
-	             "percent");
+	TablePrinter table;
 
 	for (const auto& [name, socket_id, current, maximum] : response)
 	{
-		double percent = 0.0;
-		if (maximum)
-		{
-			percent = (double)current / (double)maximum;
-			percent *= (double)100;
-		}
-
-		std::stringstream stream;
-		stream << std::fixed << std::setprecision(2) << percent;
-		std::string percent_string = stream.str();
-
-		table.insert(name,
-		             socket_id,
-		             current,
-		             maximum,
-		             percent_string);
+		table.insert_row(name, socket_id, current, maximum, utils::to_percent(current, maximum));
 	}
 
-	table.print();
+	table.Print();
 }
 
 }
diff --git a/cli/main.cpp b/cli/main.cpp
index 0cd2acb3..c13d3577 100644
--- a/cli/main.cpp
+++ b/cli/main.cpp
@@ -36,124 +36,124 @@ void help()
 std::vector<std::tuple<std::string,
                        std::string,
                        std::function<void(const std::vector<std::string>&)>>>
-        commands = {{"help", "", [](const auto& args) { call(help, args); }},
+        commands = {{"help", "", [](const auto& args) { Call(help, args); }},
                     {},
-                    {"physicalPort", "", [](const auto& args) { call(show::physicalPort, args); }},
-                    {"logicalPort", "", [](const auto& args) { call(show::logicalPort, args); }},
-                    {"acl unwind", "[module] <direction{any|in|out}> <network_source> <network_destination> <fragment{any|frag}> <protocol> <transport_source> <transport_destination> <transport_flags> <recordstate{any|true|false}>", [](const auto& args) { call(acl::unwind, args); }},
-                    {"acl lookup", "<module> <any|in|out> <network_source> <network_destination> <protocol> <transport_source> <transport_destination>", [](const auto& args) { call(acl::lookup, args); }},
-                    {"decap", "", [](const auto& args) { call(show::decap::summary, args); }},
-                    {"decap announce", "", [](const auto& args) { call(show::decap::announce, args); }},
-                    {"decap prefix allow", "[module] [ipv6_prefix] [ipv6_prefix]", [](const auto& args) { call(config::decap::allow, args); }},
-                    {"decap prefix disallow", "[module] [ipv6_prefix] [ipv6_prefix]", [](const auto& args) { call(config::decap::disallow, args); }},
-                    {"decap prefix remove", "[module] [ipv6_prefix]", [](const auto& args) { call(config::decap::remove, args); }},
-                    {"tun64", "[module]", [](const auto& args) { call(show::tun64::summary, args); }},
-                    {"tun64 announce", "[module]", [](const auto& args) { call(show::tun64::announce, args); }},
-                    {"tun64 mappings list", "[module]", [](const auto& args) { call(show::tun64::mappings, args); }},
-                    {"nat64stateful", "", [](const auto& args) { call(nat64stateful::summary, args); }},
-                    {"nat64stateful state", "<module>", [](const auto& args) { call(nat64stateful::state, args); }},
-                    {"nat64stateful announce", "", [](const auto& args) { call(nat64stateful::announce, args); }},
-                    {"nat64stateless", "", [](const auto& args) { call(show::nat64stateless::summary, args); }},
-                    {"nat64stateless translation", "", [](const auto& args) { call(show::nat64stateless::translation, args); }},
-                    {"nat64stateless announce", "", [](const auto& args) { call(show::nat64stateless::announce, args); }},
-                    {"nat64stateless prefix allow4", "[module] [ipv4_prefix] [ipv4_prefix]", [](const auto& args) { call(config::nat64stateless::allow4, args); }},
-                    {"nat64stateless prefix disallow4", "[module] [ipv4_prefix] [ipv4_prefix]", [](const auto& args) { call(config::nat64stateless::disallow4, args); }},
-                    {"nat64stateless prefix remove4", "[module] [ipv4_prefix]", [](const auto& args) { call(config::nat64stateless::remove4, args); }},
-                    {"nat64stateless prefix allow6", "[module] [ipv6_prefix] [ipv6_prefix]", [](const auto& args) { call(config::nat64stateless::allow6, args); }},
-                    {"nat64stateless prefix disallow6", "[module] [ipv6_prefix] [ipv6_prefix]", [](const auto& args) { call(config::nat64stateless::disallow6, args); }},
-                    {"nat64stateless prefix remove6", "[module] [ipv6_prefix]", [](const auto& args) { call(config::nat64stateless::remove6, args); }},
-                    {"nat46clat", "", [](const auto& args) { call(nat46clat::summary, args); }},
-                    {"nat46clat announce", "", [](const auto& args) { call(nat46clat::announce, args); }},
-                    {"balancer", "", [](const auto& args) { call(balancer::summary, args); }},
-                    {"balancer service", "[module] <virtual_ip> <proto> <virtual_port>", [](const auto& args) { call(balancer::service, args); }},
-                    {"balancer real", "[module] <virtual_ip> <proto> <virtual_port> <real_ip> <real_port>", [](const auto& args) { call(balancer::real_find, args); }},
-                    {"balancer state", "[module] <virtual_ip> <proto> <virtual_port> <real_ip> <real_port>", [](const auto& args) { call(balancer::state, args); }},
-                    {"balancer real enable", "[module] [virtual_ip] [proto] [virtual_port] [real_ip] [real_port] <real_weight>", [](const auto& args) { call(balancer::real::enable, args); }},
-                    {"balancer real disable", "[module] [virtual_ip] [proto] [virtual_port] [real_ip] [real_port]", [](const auto& args) { call(balancer::real::disable, args); }},
-                    {"balancer real flush", "", [](const auto& args) { call(balancer::real::flush, args); }},
-                    {"balancer announce", "", [](const auto& args) { call(balancer::announce, args); }},
-                    {"route", "", [](const auto& args) { call(route::summary, args); }},
-                    {"route interface", "", [](const auto& args) { call(route::interface, args); }},
-                    {"route lookup", "[module] [ip_address]", [](const auto& args) { call(route::lookup, args); }},
-                    {"route get", "[module] [ip_prefix]", [](const auto& args) { call(route::get, args); }},
-                    {"route tunnel lookup", "[module] [ip_address]", [](const auto& args) { call(route::tunnel::lookup, args); }},
-                    {"route tunnel get", "[module] [ip_prefix]", [](const auto& args) { call(route::tunnel::get, args); }},
-                    {"route counters", "", [](const auto& args) { call(route::counters, args); }},
-                    {"route tunnel counters", "", [](const auto& args) { call(route::tunnel::counters, args); }},
-                    {"neighbor show", "", [](const auto& args) { call(neighbor::show, args); }},
-                    {"neighbor insert", "[route_name] [interface_name] [ip_address] [mac_address]", [](const auto& args) { call(neighbor::insert, args); }},
-                    {"neighbor remove", "[route_name] [interface_name] [ip_address]", [](const auto& args) { call(neighbor::remove, args); }},
-                    {"neighbor flush", "", [](const auto& args) { call(neighbor::flush, args); }},
-                    {"rib", "", [](const auto& args) { call(rib::summary, args); }},
-                    {"rib prefixes", "", [](const auto& args) { call(rib::prefixes, args); }},
-                    {"rib lookup", "[vrf] [ip_address]", [](const auto& args) { call(rib::lookup, args); }},
-                    {"rib get", "[vrf] [ip_prefix]", [](const auto& args) { call(rib::get, args); }},
-                    {"rib static insert", "[vrf] [ip_prefix] [nexthop] <label> <peer_id> <origin_as> <weight>", [](const auto& args) { call(rib::insert, args); }},
-                    {"rib static remove", "[vrf] [ip_prefix] [nexthop] <label> <peer_id>", [](const auto& args) { call(rib::remove, args); }},
-                    {"dregress", "", [](const auto& args) { call(dregress::summary, args); }},
-                    {"dregress announce", "", [](const auto& args) { call(dregress::announce, args); }},
-                    {"limit", "", [](const auto& args) { call(limit::summary, args); }},
-                    {"values", "", [](const auto& args) { call(show::values, args); }},
-                    {"durations", "", [](const auto& args) { call(show::durations, args); }},
-                    {"memory show", "", [](const auto& args) { call(memory_manager::show, args); }},
-                    {"memory group", "", [](const auto& args) { call(memory_manager::group, args); }},
-                    {"dump", "[in|out|drop] [interface_name] [enable|disable]", [](const auto& args) { call(show::physical_port_dump, args); }},
+                    {"physicalPort", "", [](const auto& args) { Call(show::physicalPort, args); }},
+                    {"logicalPort", "", [](const auto& args) { Call(show::logicalPort, args); }},
+                    {"acl unwind", "[module] <direction{any|in|out}> <network_source> <network_destination> <fragment{any|frag}> <protocol> <transport_source> <transport_destination> <transport_flags> <recordstate{any|true|false}>", [](const auto& args) { Call(acl::unwind, args); }},
+                    {"acl lookup", "<module> <any|in|out> <network_source> <network_destination> <protocol> <transport_source> <transport_destination>", [](const auto& args) { Call(acl::lookup, args); }},
+                    {"decap", "", [](const auto& args) { Call(show::decap::summary, args); }},
+                    {"decap announce", "", [](const auto& args) { Call(show::decap::announce, args); }},
+                    {"decap prefix allow", "[module] [ipv6_prefix] [ipv6_prefix]", [](const auto& args) { Call(config::decap::allow, args); }},
+                    {"decap prefix disallow", "[module] [ipv6_prefix] [ipv6_prefix]", [](const auto& args) { Call(config::decap::disallow, args); }},
+                    {"decap prefix remove", "[module] [ipv6_prefix]", [](const auto& args) { Call(config::decap::remove, args); }},
+                    {"tun64", "[module]", [](const auto& args) { Call(show::tun64::summary, args); }},
+                    {"tun64 announce", "[module]", [](const auto& args) { Call(show::tun64::announce, args); }},
+                    {"tun64 mappings list", "[module]", [](const auto& args) { Call(show::tun64::mappings, args); }},
+                    {"nat64stateful", "", [](const auto& args) { Call(nat64stateful::summary, args); }},
+                    {"nat64stateful state", "<module>", [](const auto& args) { Call(nat64stateful::state, args); }},
+                    {"nat64stateful announce", "", [](const auto& args) { Call(nat64stateful::announce, args); }},
+                    {"nat64stateless", "", [](const auto& args) { Call(show::nat64stateless::summary, args); }},
+                    {"nat64stateless translation", "", [](const auto& args) { Call(show::nat64stateless::translation, args); }},
+                    {"nat64stateless announce", "", [](const auto& args) { Call(show::nat64stateless::announce, args); }},
+                    {"nat64stateless prefix allow4", "[module] [ipv4_prefix] [ipv4_prefix]", [](const auto& args) { Call(config::nat64stateless::allow4, args); }},
+                    {"nat64stateless prefix disallow4", "[module] [ipv4_prefix] [ipv4_prefix]", [](const auto& args) { Call(config::nat64stateless::disallow4, args); }},
+                    {"nat64stateless prefix remove4", "[module] [ipv4_prefix]", [](const auto& args) { Call(config::nat64stateless::remove4, args); }},
+                    {"nat64stateless prefix allow6", "[module] [ipv6_prefix] [ipv6_prefix]", [](const auto& args) { Call(config::nat64stateless::allow6, args); }},
+                    {"nat64stateless prefix disallow6", "[module] [ipv6_prefix] [ipv6_prefix]", [](const auto& args) { Call(config::nat64stateless::disallow6, args); }},
+                    {"nat64stateless prefix remove6", "[module] [ipv6_prefix]", [](const auto& args) { Call(config::nat64stateless::remove6, args); }},
+                    {"nat46clat", "", [](const auto& args) { Call(nat46clat::summary, args); }},
+                    {"nat46clat announce", "", [](const auto& args) { Call(nat46clat::announce, args); }},
+                    {"balancer", "", [](const auto& args) { Call(balancer::summary, args); }},
+                    {"balancer service", "[module] <virtual_ip> <proto> <virtual_port>", [](const auto& args) { Call(balancer::service, args); }},
+                    {"balancer real", "[module] <virtual_ip> <proto> <virtual_port> <real_ip> <real_port>", [](const auto& args) { Call(balancer::real_find, args); }},
+                    {"balancer state", "[module] <virtual_ip> <proto> <virtual_port> <real_ip> <real_port>", [](const auto& args) { Call(balancer::state, args); }},
+                    {"balancer real enable", "[module] [virtual_ip] [proto] [virtual_port] [real_ip] [real_port] <real_weight>", [](const auto& args) { Call(balancer::real::enable, args); }},
+                    {"balancer real disable", "[module] [virtual_ip] [proto] [virtual_port] [real_ip] [real_port]", [](const auto& args) { Call(balancer::real::disable, args); }},
+                    {"balancer real flush", "", [](const auto& args) { Call(balancer::real::flush, args); }},
+                    {"balancer announce", "", [](const auto& args) { Call(balancer::announce, args); }},
+                    {"route", "", [](const auto& args) { Call(route::summary, args); }},
+                    {"route interface", "", [](const auto& args) { Call(route::interface, args); }},
+                    {"route lookup", "[module] [ip_address]", [](const auto& args) { Call(route::lookup, args); }},
+                    {"route get", "[module] [ip_prefix]", [](const auto& args) { Call(route::get, args); }},
+                    {"route tunnel lookup", "[module] [ip_address]", [](const auto& args) { Call(route::tunnel::lookup, args); }},
+                    {"route tunnel get", "[module] [ip_prefix]", [](const auto& args) { Call(route::tunnel::get, args); }},
+                    {"route counters", "", [](const auto& args) { Call(route::counters, args); }},
+                    {"route tunnel counters", "", [](const auto& args) { Call(route::tunnel::counters, args); }},
+                    {"neighbor show", "", [](const auto& args) { Call(neighbor::show, args); }},
+                    {"neighbor insert", "[route_name] [interface_name] [ip_address] [mac_address]", [](const auto& args) { Call(neighbor::insert, args); }},
+                    {"neighbor remove", "[route_name] [interface_name] [ip_address]", [](const auto& args) { Call(neighbor::remove, args); }},
+                    {"neighbor flush", "", [](const auto& args) { Call(neighbor::flush, args); }},
+                    {"rib", "", [](const auto& args) { Call(rib::summary, args); }},
+                    {"rib prefixes", "", [](const auto& args) { Call(rib::prefixes, args); }},
+                    {"rib lookup", "[vrf] [ip_address]", [](const auto& args) { Call(rib::lookup, args); }},
+                    {"rib get", "[vrf] [ip_prefix]", [](const auto& args) { Call(rib::get, args); }},
+                    {"rib static insert", "[vrf] [ip_prefix] [nexthop] <label> <peer_id> <origin_as> <weight>", [](const auto& args) { Call(rib::insert, args); }},
+                    {"rib static remove", "[vrf] [ip_prefix] [nexthop] <label> <peer_id>", [](const auto& args) { Call(rib::remove, args); }},
+                    {"dregress", "", [](const auto& args) { Call(dregress::summary, args); }},
+                    {"dregress announce", "", [](const auto& args) { Call(dregress::announce, args); }},
+                    {"limit", "", [](const auto& args) { Call(limit::summary, args); }},
+                    {"values", "", [](const auto& args) { Call(show::values, args); }},
+                    {"durations", "", [](const auto& args) { Call(show::durations, args); }},
+                    {"memory show", "", [](const auto& args) { Call(memory_manager::show, args); }},
+                    {"memory group", "", [](const auto& args) { Call(memory_manager::group, args); }},
+                    {"dump", "[in|out|drop] [interface_name] [enable|disable]", [](const auto& args) { Call(show::physical_port_dump, args); }},
                     {},
-                    {"show errors", "", [](const auto& args) { call(show::errors, args); }},
+                    {"show errors", "", [](const auto& args) { Call(show::errors, args); }},
                     {},
-                    {"fw show", "<original|generated|state|all|dispatcher>", [](const auto& args) { call(show::fw, args); }},
-                    {"fw list", "<original|generated|state|all|dispatcher>", [](const auto& args) { call(show::fwlist, args); }},
+                    {"fw show", "<original|generated|state|all|dispatcher>", [](const auto& args) { Call(show::fw, args); }},
+                    {"fw list", "<original|generated|state|all|dispatcher>", [](const auto& args) { Call(show::fwlist, args); }},
                     {},
-                    {"show shm info", "", [](const auto& args) { call(show::shm_info, args); }},
+                    {"show shm info", "", [](const auto& args) { Call(show::shm_info, args); }},
                     {},
-                    {"tsc show shm info", "", [](const auto& args) { call(show::shm_tsc_info, args); }},
-                    {"tsc set state", "[true|false]", [](const auto& args) { call(show::shm_tsc_set_state, args); }},
-                    {"tsc set base", "[handle] [value]", [](const auto& args) { call(show::shm_tsc_set_base_value, args); }},
+                    {"tsc show shm info", "", [](const auto& args) { Call(show::shm_tsc_info, args); }},
+                    {"tsc set state", "[true|false]", [](const auto& args) { Call(show::shm_tsc_set_state, args); }},
+                    {"tsc set base", "[handle] [value]", [](const auto& args) { Call(show::shm_tsc_set_base_value, args); }},
                     {},
-                    {"samples show", "", [](const auto& args) { call(show::samples, args); }},
-                    {"samples dump", "", [](const auto& args) { call(show::samples_dump, args); }},
+                    {"samples show", "", [](const auto& args) { Call(show::samples, args); }},
+                    {"samples dump", "", [](const auto& args) { Call(show::samples_dump, args); }},
                     {},
-                    {"dontdoit podumoi dataplane lpm4LookupAddress", "[ipv4_address]", [](const auto& args) { call(develop::dataplane::lpm4LookupAddress, args); }},
-                    {"dontdoit podumoi dataplane lpm6LookupAddress", "[ipv6_address]", [](const auto& args) { call(develop::dataplane::lpm6LookupAddress, args); }},
-                    {"dontdoit podumoi dataplane error", "", [](const auto& args) { call(develop::dataplane::getErrors, args); }},
-                    {"dontdoit podumoi dataplane report", "", [](const auto& args) { call(develop::dataplane::getReport, args); }},
-                    {"dontdoit podumoi dataplane counter", "[counter_id] <range_size>", [](const auto& args) { call(develop::dataplane::counter, args); }},
-                    {"dontdoit podumoi controlplane rib save", "", [](const auto& args) { call(rib::save, args); }},
-                    {"dontdoit podumoi controlplane rib load", "", [](const auto& args) { call(rib::load, args); }},
-                    {"dontdoit podumoi controlplane rib clear", "[protocol] <peer> <vrf> <priority>", [](const auto& args) { call(rib::clear, args); }},
-                    {"dontdoit podumoi tsc monitoring", "", [](const auto& args) { call(develop::dataplane::tsc_monitoring, args); }},
+                    {"dontdoit podumoi dataplane lpm4LookupAddress", "[ipv4_address]", [](const auto& args) { Call(develop::dataplane::lpm4LookupAddress, args); }},
+                    {"dontdoit podumoi dataplane lpm6LookupAddress", "[ipv6_address]", [](const auto& args) { Call(develop::dataplane::lpm6LookupAddress, args); }},
+                    {"dontdoit podumoi dataplane error", "", [](const auto& args) { Call(develop::dataplane::getErrors, args); }},
+                    {"dontdoit podumoi dataplane report", "", [](const auto& args) { Call(develop::dataplane::getReport, args); }},
+                    {"dontdoit podumoi dataplane counter", "[counter_id] <range_size>", [](const auto& args) { Call(develop::dataplane::counter, args); }},
+                    {"dontdoit podumoi controlplane rib save", "", [](const auto& args) { Call(rib::save, args); }},
+                    {"dontdoit podumoi controlplane rib load", "", [](const auto& args) { Call(rib::load, args); }},
+                    {"dontdoit podumoi controlplane rib clear", "[protocol] <peer> <vrf> <priority>", [](const auto& args) { Call(rib::clear, args); }},
+                    {"dontdoit podumoi tsc monitoring", "", [](const auto& args) { Call(develop::dataplane::tsc_monitoring, args); }},
                     {},
-                    {"telegraf unsafe", "", [](const auto& args) { call(telegraf::unsafe, args); }},
-                    {"telegraf ports", "", [](const auto& args) { call(telegraf::ports_stats, args); }},
-                    {"telegraf dregress", "", [](const auto& args) { call(telegraf::dregress, args); }},
-                    {"telegraf peer", "", [](const auto& args) { call(telegraf::dregress_traffic, args); }},
-                    {"telegraf balancer service", "", [](const auto& args) { call(telegraf::balancer::service, args); }},
-                    {"telegraf other", "", [](const auto& args) { call(telegraf::other, args); }},
-                    {"telegraf tun64", "", [](const auto& args) { call(telegraf::mappings, args); }},
-                    {"telegraf counters", "", [](const auto& args) { call(telegraf::main_counters, args); }},
-                    {"telegraf bus", "", [](const auto& args) { call(bus::bus_telegraf, args); }},
-                    {"telegraf route", "", [](const auto& args) { call(telegraf::route, args); }},
-                    {"telegraf route tunnel", "", [](const auto& args) { call(telegraf::route_tunnel, args); }},
+                    {"telegraf unsafe", "", [](const auto& args) { Call(telegraf::unsafe, args); }},
+                    {"telegraf ports", "", [](const auto& args) { Call(telegraf::ports_stats, args); }},
+                    {"telegraf dregress", "", [](const auto& args) { Call(telegraf::dregress, args); }},
+                    {"telegraf peer", "", [](const auto& args) { Call(telegraf::dregress_traffic, args); }},
+                    {"telegraf balancer service", "", [](const auto& args) { Call(telegraf::balancer::service, args); }},
+                    {"telegraf other", "", [](const auto& args) { Call(telegraf::other, args); }},
+                    {"telegraf tun64", "", [](const auto& args) { Call(telegraf::mappings, args); }},
+                    {"telegraf counters", "", [](const auto& args) { Call(telegraf::main_counters, args); }},
+                    {"telegraf bus", "", [](const auto& args) { Call(bus::bus_telegraf, args); }},
+                    {"telegraf route", "", [](const auto& args) { Call(telegraf::route, args); }},
+                    {"telegraf route tunnel", "", [](const auto& args) { Call(telegraf::route_tunnel, args); }},
                     {},
-                    {"reload", "", [](const auto& args) { call(config::reload, args); }},
-                    {"version", "", [](const auto& args) { call(show::version, args); }},
-                    {"latch update dataplane", "<latch name> <state>", [](const auto& args) { call(latch::dataplane_update, args); }},
-                    {"counter", "[counter_name] <core_id>", [](const auto& args) { call(show::counter_by_name, args); }},
-                    {"counters stat", "", [](const auto& args) { call(show::counters_stat, args); }},
+                    {"reload", "", [](const auto& args) { Call(config::reload, args); }},
+                    {"version", "", [](const auto& args) { Call(show::version, args); }},
+                    {"latch update dataplane", "<latch name> <state>", [](const auto& args) { Call(latch::dataplane_update, args); }},
+                    {"counter", "[counter_name] <core_id>", [](const auto& args) { Call(show::counter_by_name, args); }},
+                    {"counters stat", "", [](const auto& args) { Call(show::counters_stat, args); }},
 
-                    {"bus requests", "", [](const auto& args) { call(bus::bus_requests, args); }},
-                    {"bus errors", "", [](const auto& args) { call(bus::bus_errors, args); }},
+                    {"bus requests", "", [](const auto& args) { Call(bus::bus_requests, args); }},
+                    {"bus errors", "", [](const auto& args) { Call(bus::bus_errors, args); }},
 
-                    {"latch update dataplane", "<latch name> <state>", [](const auto& args) { call(latch::dataplane_update, args); }},
+                    {"latch update dataplane", "<latch name> <state>", [](const auto& args) { Call(latch::dataplane_update, args); }},
                     {},
-                    {"convert logical_module", "", [](const auto& args) { call(convert::logical_module, args); }}};
+                    {"convert logical_module", "", [](const auto& args) { Call(convert::logical_module, args); }}};
 
 void printUsage()
 {
 	printf("usage:\n");
 	for (const auto& [command, args, function] : commands)
 	{
-		(void)function;
+		YANET_GCC_BUG_UNUSED(function);
 
 		if (command.empty())
 		{
diff --git a/cli/memory_manager.h b/cli/memory_manager.h
index 95d4a677..f92606e5 100644
--- a/cli/memory_manager.h
+++ b/cli/memory_manager.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #include "common/idataplane.h"
-#include "helper.h"
+#include "table_printer.h"
 
 namespace memory_manager
 {
@@ -12,28 +12,22 @@ void show()
 
 	const auto response = dataplane.memory_manager_stats();
 	const auto& [response_memory_group, response_objects] = response;
-	(void)response_memory_group;
+	YANET_GCC_BUG_UNUSED(response_memory_group);
 
-	table_t table;
-	table.insert("name",
-	             "socket_id",
-	             "current");
+	TablePrinter table;
+	table.insert_row("name", "socket_id", "current");
 
 	uint64_t total = 0;
 	for (const auto& [name, socket_id, current] : response_objects)
 	{
 		total += current;
 
-		table.insert(name,
-		             socket_id,
-		             current);
+		table.insert_row(name, socket_id, current);
 	}
 
-	table.insert("total",
-	             "n/s",
-	             total);
+	table.insert_row("total", "n/s", total);
 
-	table.print();
+	table.Print();
 }
 
 void group()
@@ -43,11 +37,8 @@ void group()
 	const auto response = dataplane.memory_manager_stats();
 	const auto& [response_memory_group, response_objects] = response;
 
-	table_t table;
-	table.insert("group",
-	             "current",
-	             "maximum",
-	             "percent");
+	TablePrinter table;
+	table.insert_row("group", "current", "maximum", "percent");
 
 	std::map<std::string, ///< object_name
 	         common::uint64> ///< current
@@ -55,10 +46,9 @@ void group()
 
 	for (const auto& [name, socket_id, current] : response_objects)
 	{
-		(void)socket_id;
+		YANET_GCC_BUG_UNUSED(socket_id);
 
-		currents[name] = std::max(currents[name].value,
-		                          current);
+		currents[name] = std::max(currents[name].value, current);
 	}
 
 	response_memory_group.for_each([&](const auto& memory_group,
@@ -79,16 +69,12 @@ void group()
 		if (memory_group.limit)
 		{
 			maximum = memory_group.limit;
-			percent = to_percent(group_total, memory_group.limit);
+			percent = utils::to_percent(group_total, memory_group.limit);
 		}
 
-		table.insert(memory_group.name,
-		             group_total,
-		             maximum,
-		             percent);
+		table.insert_row(memory_group.name, group_total, maximum, percent);
 	});
 
-	table.print();
+	table.Print();
 }
-
 }
diff --git a/cli/nat46clat.h b/cli/nat46clat.h
index f9012005..c62f218c 100644
--- a/cli/nat46clat.h
+++ b/cli/nat46clat.h
@@ -1,8 +1,9 @@
 #pragma once
 
+#include "cli/helper.h"
 #include "common/icontrolplane.h"
 
-#include "helper.h"
+#include "table_printer.h"
 
 namespace nat46clat
 {
@@ -12,21 +13,21 @@ void summary()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.nat46clat_config();
 
-	table_t table;
-	table.insert("module",
-	             "ipv6_source",
-	             "ipv6_destination",
-	             "next_module");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "ipv6_source",
+	                 "ipv6_destination",
+	                 "next_module");
 
 	for (const auto& [module_name, nat46clat] : response)
 	{
-		table.insert(module_name,
-		             nat46clat.ipv6_source,
-		             nat46clat.ipv6_destination,
-		             nat46clat.next_module);
+		table.insert_row(module_name,
+		                 nat46clat.ipv6_source,
+		                 nat46clat.ipv6_destination,
+		                 nat46clat.next_module);
 	}
 
-	table.print();
+	table.Print();
 }
 
 void announce()
@@ -34,17 +35,7 @@ void announce()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.nat46clat_announce();
 
-	table_t table;
-	table.insert("module",
-	             "announces");
-
-	for (const auto& [module_name, prefix] : response)
-	{
-		table.insert(module_name,
-		             prefix);
-	}
-
-	table.print();
+	FillAndPrintTable({"module", "announces"}, response);
 }
 
 }
diff --git a/cli/nat64stateful.h b/cli/nat64stateful.h
index 88e98e4a..ffe1412e 100644
--- a/cli/nat64stateful.h
+++ b/cli/nat64stateful.h
@@ -1,9 +1,10 @@
 #pragma once
 
+#include "cli/helper.h"
 #include "common/icontrolplane.h"
 #include "common/idataplane.h"
 
-#include "helper.h"
+#include "table_printer.h"
 
 namespace nat64stateful
 {
@@ -13,10 +14,10 @@ void summary()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.nat64stateful_config();
 
-	table_t table;
-	table.insert("module",
-	             "ipv4_pool_size",
-	             "next_module");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "ipv4_pool_size",
+	                 "next_module");
 
 	for (const auto& [name, nat64stateful] : response)
 	{
@@ -26,12 +27,12 @@ void summary()
 			ipv4_pool_size += (1u << (32 - ipv4_prefix.mask()));
 		}
 
-		table.insert(name,
-		             ipv4_pool_size,
-		             nat64stateful.next_module);
+		table.insert_row(name,
+		                 ipv4_pool_size,
+		                 nat64stateful.next_module);
 	}
 
-	table.print();
+	table.Print();
 }
 
 void announce()
@@ -39,17 +40,7 @@ void announce()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.nat64stateful_announce();
 
-	table_t table;
-	table.insert("module",
-	             "announces");
-
-	for (const auto& [module, announces] : response)
-	{
-		table.insert(module,
-		             announces);
-	}
-
-	table.print();
+	FillAndPrintTable({"module", "announces"}, response);
 }
 
 /// @todo: move
@@ -152,19 +143,19 @@ void state(std::optional<std::string> module)
 	interface::dataPlane dataplane;
 	const auto response = dataplane.nat64stateful_state({module_id});
 
-	table_t table;
-	table.insert("module",
-	             "ipv6_source",
-	             "ipv4_source",
-	             "ipv4_destination",
-	             "proto",
-	             "origin_port_source",
-	             "port_source",
-	             "port_destination",
-	             "lan_flags",
-	             "wan_flags",
-	             "lan_last_seen",
-	             "wan_last_seen");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "ipv6_source",
+	                 "ipv4_source",
+	                 "ipv4_destination",
+	                 "proto",
+	                 "origin_port_source",
+	                 "port_source",
+	                 "port_destination",
+	                 "lan_flags",
+	                 "wan_flags",
+	                 "lan_last_seen",
+	                 "wan_last_seen");
 
 	for (const auto& [nat64stateful_id,
 	                  proto,
@@ -185,21 +176,21 @@ void state(std::optional<std::string> module)
 			it = modules.emplace_hint(it, nat64stateful_id, "unknown");
 		}
 
-		table.insert(it->second,
-		             ipv6_source,
-		             ipv4_source,
-		             ipv6_destination.get_mapped_ipv4_address().toString().data(),
-		             proto_to_string(proto).data(),
-		             port_source,
-		             wan_port_source,
-		             port_destination,
-		             tcp_flags_to_string(lan_flags),
-		             tcp_flags_to_string(wan_flags),
-		             lan_last_seen,
-		             wan_last_seen);
+		table.insert_row(it->second,
+		                 ipv6_source,
+		                 ipv4_source,
+		                 ipv6_destination.get_mapped_ipv4_address().toString().data(),
+		                 proto_to_string(proto).data(),
+		                 port_source,
+		                 wan_port_source,
+		                 port_destination,
+		                 tcp_flags_to_string(lan_flags),
+		                 tcp_flags_to_string(wan_flags),
+		                 lan_last_seen,
+		                 wan_last_seen);
 	}
 
-	table.print();
+	table.Print();
 }
 
 }
diff --git a/cli/neighbor.h b/cli/neighbor.h
index 2a961cbe..a68803de 100644
--- a/cli/neighbor.h
+++ b/cli/neighbor.h
@@ -1,9 +1,8 @@
 #pragma once
 
+#include "cli/helper.h"
 #include "common/idataplane.h"
 
-#include "helper.h"
-
 namespace neighbor
 {
 
@@ -12,27 +11,13 @@ void show()
 	interface::dataPlane dataplane;
 	const auto response = dataplane.neighbor_show();
 
-	table_t table({.optional_null = "static"});
-	table.insert("route_name",
-	             "interface_name",
-	             "ip_address",
-	             "mac_address",
-	             "last_update");
-
-	for (const auto& [route_name,
-	                  interface_name,
-	                  ip_address,
-	                  mac_address,
-	                  last_update] : response)
-	{
-		table.insert(route_name,
-		             interface_name,
-		             ip_address,
-		             mac_address,
-		             last_update);
-	}
-
-	table.print();
+	FillAndPrintTable({"route_name",
+	                   "interface_name",
+	                   "ip_address",
+	                   "mac_address",
+	                   "last_update"},
+	                  response,
+	                  {.optional_null = "static"});
 }
 
 void insert(const std::string& route_name,
diff --git a/cli/rib.h b/cli/rib.h
index aeb8880c..0b83b248 100644
--- a/cli/rib.h
+++ b/cli/rib.h
@@ -4,7 +4,7 @@
 
 #include "common/icontrolplane.h"
 
-#include "helper.h"
+#include "table_printer.h"
 
 namespace rib
 {
@@ -14,32 +14,32 @@ void summary()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.rib_summary();
 
-	table_t table;
-	table.insert("vrf",
-	             "priority",
-	             "protocol",
-	             "peer",
-	             "table_name",
-	             "prefixes",
-	             "paths",
-	             "eor");
+	TablePrinter table;
+	table.insert_row("vrf",
+	                 "priority",
+	                 "protocol",
+	                 "peer",
+	                 "table_name",
+	                 "prefixes",
+	                 "paths",
+	                 "eor");
 
 	for (const auto& [key, value] : response)
 	{
 		const auto& [vrf, priority, protocol, peer, table_name] = key;
 		const auto& [prefixes, paths, eor] = value;
 
-		table.insert(vrf,
-		             priority,
-		             protocol,
-		             peer,
-		             table_name,
-		             prefixes,
-		             paths,
-		             (bool)eor);
+		table.insert_row(vrf,
+		                 priority,
+		                 protocol,
+		                 peer,
+		                 table_name,
+		                 prefixes,
+		                 paths,
+		                 (bool)eor);
 	}
 
-	table.print();
+	table.Print();
 }
 
 void prefixes()
@@ -47,22 +47,22 @@ void prefixes()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.rib_prefixes();
 
-	table_t table;
-	table.insert("vrf",
-	             "priority",
-	             "prefix",
-	             "protocol",
-	             "peer",
-	             "table_name",
-	             "path_information",
-	             "nexthop",
-	             "labels",
-	             "local_preference",
-	             "aspath",
-	             "origin",
-	             "med",
-	             "communities",
-	             "large_communities");
+	TablePrinter table;
+	table.insert_row("vrf",
+	                 "priority",
+	                 "prefix",
+	                 "protocol",
+	                 "peer",
+	                 "table_name",
+	                 "path_information",
+	                 "nexthop",
+	                 "labels",
+	                 "local_preference",
+	                 "aspath",
+	                 "origin",
+	                 "med",
+	                 "communities",
+	                 "large_communities");
 
 	for (const auto& [vrf_priority, prefix_nexthops] : response)
 	{
@@ -75,26 +75,26 @@ void prefixes()
 				const auto& [protocol, peer, table_name, path_information] = nexthop_key;
 				const auto& [nexthop, labels, origin, med, aspath, communities, large_communities, local_preference] = nexthop_value;
 
-				table.insert(vrf,
-				             priority,
-				             prefix,
-				             protocol,
-				             peer,
-				             table_name,
-				             path_information,
-				             nexthop,
-				             labels,
-				             local_preference,
-				             aspath,
-				             origin,
-				             med,
-				             communities,
-				             large_communities);
+				table.insert_row(vrf,
+				                 priority,
+				                 prefix,
+				                 protocol,
+				                 peer,
+				                 table_name,
+				                 path_information,
+				                 nexthop,
+				                 labels,
+				                 local_preference,
+				                 aspath,
+				                 origin,
+				                 med,
+				                 communities,
+				                 large_communities);
 			}
 		}
 	}
 
-	table.print();
+	table.Print();
 }
 
 void lookup(const std::string& vrf,
@@ -103,22 +103,22 @@ void lookup(const std::string& vrf,
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.rib_lookup({vrf, address});
 
-	table_t table;
-	table.insert("vrf",
-	             "priority",
-	             "prefix",
-	             "protocol",
-	             "peer",
-	             "table_name",
-	             "path_information",
-	             "nexthop",
-	             "labels",
-	             "local_preference",
-	             "aspath",
-	             "origin",
-	             "med",
-	             "communities",
-	             "large_communities");
+	TablePrinter table;
+	table.insert_row("vrf",
+	                 "priority",
+	                 "prefix",
+	                 "protocol",
+	                 "peer",
+	                 "table_name",
+	                 "path_information",
+	                 "nexthop",
+	                 "labels",
+	                 "local_preference",
+	                 "aspath",
+	                 "origin",
+	                 "med",
+	                 "communities",
+	                 "large_communities");
 
 	for (const auto& [vrf_priority, prefix_nexthops] : response)
 	{
@@ -131,26 +131,26 @@ void lookup(const std::string& vrf,
 				const auto& [protocol, peer, table_name, path_information] = nexthop_key;
 				const auto& [nexthop, labels, origin, med, aspath, communities, large_communities, local_preference] = nexthop_value;
 
-				table.insert(vrf,
-				             priority,
-				             prefix,
-				             protocol,
-				             peer,
-				             table_name,
-				             path_information,
-				             nexthop,
-				             labels,
-				             local_preference,
-				             aspath,
-				             origin,
-				             med,
-				             communities,
-				             large_communities);
+				table.insert_row(vrf,
+				                 priority,
+				                 prefix,
+				                 protocol,
+				                 peer,
+				                 table_name,
+				                 path_information,
+				                 nexthop,
+				                 labels,
+				                 local_preference,
+				                 aspath,
+				                 origin,
+				                 med,
+				                 communities,
+				                 large_communities);
 			}
 		}
 	}
 
-	table.print();
+	table.Print();
 }
 
 void get(const std::string& vrf,
@@ -159,21 +159,21 @@ void get(const std::string& vrf,
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.rib_get({vrf, prefix});
 
-	table_t table;
-	table.insert("vrf",
-	             "priority",
-	             "protocol",
-	             "peer",
-	             "table_name",
-	             "path_information",
-	             "nexthop",
-	             "labels",
-	             "local_preference",
-	             "aspath",
-	             "origin",
-	             "med",
-	             "communities",
-	             "large_communities");
+	TablePrinter table;
+	table.insert_row("vrf",
+	                 "priority",
+	                 "protocol",
+	                 "peer",
+	                 "table_name",
+	                 "path_information",
+	                 "nexthop",
+	                 "labels",
+	                 "local_preference",
+	                 "aspath",
+	                 "origin",
+	                 "med",
+	                 "communities",
+	                 "large_communities");
 
 	for (const auto& [vrf_priority, prefix_nexthops] : response)
 	{
@@ -185,48 +185,33 @@ void get(const std::string& vrf,
 			{
 				const auto& [protocol, peer, table_name, path_information] = nexthop_key;
 				const auto& [nexthop, labels, origin, med, aspath, communities, large_communities, local_preference] = nexthop_value;
-				(void)prefix;
-
-				table.insert(vrf,
-				             priority,
-				             protocol,
-				             peer,
-				             table_name,
-				             path_information,
-				             nexthop,
-				             labels,
-				             local_preference,
-				             aspath,
-				             origin,
-				             med,
-				             communities,
-				             large_communities);
+				YANET_GCC_BUG_UNUSED(prefix);
+
+				table.insert_row(vrf,
+				                 priority,
+				                 protocol,
+				                 peer,
+				                 table_name,
+				                 path_information,
+				                 nexthop,
+				                 labels,
+				                 local_preference,
+				                 aspath,
+				                 origin,
+				                 med,
+				                 communities,
+				                 large_communities);
 			}
 		}
 	}
 
-	table.print();
-}
-
-std::vector<std::string> split(const std::string& string,
-                               char delimiter = ' ')
-{
-	std::vector<std::string> result;
-
-	std::stringstream stream(string);
-	std::string item;
-	while (std::getline(stream, item, delimiter))
-	{
-		result.emplace_back(item);
-	}
-
-	return result;
+	table.Print();
 }
 
 void convert(const std::string& string,
              std::tuple<std::string, common::ip_address_t, std::vector<uint32_t>>& result)
 {
-	auto nexthop_label_string = split(string, '+');
+	auto nexthop_label_string = utils::split(string, '+');
 
 	if (nexthop_label_string.size() == 1)
 	{
diff --git a/cli/route.h b/cli/route.h
index c398db1d..034ffc0b 100644
--- a/cli/route.h
+++ b/cli/route.h
@@ -1,10 +1,10 @@
 #pragma once
 
-#include <iomanip>
-
+#include "cli/helper.h"
 #include "common/icontrolplane.h"
 
-#include "helper.h"
+#include "common/utils.h"
+#include "table_printer.h"
 
 namespace route
 {
@@ -14,17 +14,7 @@ void summary()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.route_summary();
 
-	table_t table;
-	table.insert("module",
-	             "vrf");
-
-	for (const auto& [route_name, vrf] : response)
-	{
-		table.insert(route_name,
-		             vrf);
-	}
-
-	table.print();
+	FillAndPrintTable({"module", "vrf"}, response);
 }
 
 void interface()
@@ -32,32 +22,32 @@ void interface()
 	interface::controlPlane controlplane;
 	const auto response = controlplane.route_interface();
 
-	table_t table;
-	table.insert("module",
-	             "interface",
-	             "address",
-	             "neighbor_v4",
-	             "neighbor_v6",
-	             "neighbor_mac_address_v4",
-	             "neighbor_mac_address_v6",
-	             "next_module");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "interface",
+	                 "address",
+	                 "neighbor_v4",
+	                 "neighbor_v6",
+	                 "neighbor_mac_address_v4",
+	                 "neighbor_mac_address_v6",
+	                 "next_module");
 
 	for (const auto& [key, value] : response)
 	{
 		const auto& [route_name, interface_name] = key;
 		const auto& [address, neighbor_v4, neighbor_v6, neighbor_mac_address_v4, neighbor_mac_address_v6, next_module] = value;
 
-		table.insert(route_name,
-		             interface_name,
-		             address,
-		             neighbor_v4,
-		             neighbor_v6,
-		             neighbor_mac_address_v4,
-		             neighbor_mac_address_v6,
-		             next_module == "controlPlane" ? std::string("linux") : next_module);
+		table.insert_row(route_name,
+		                 interface_name,
+		                 address,
+		                 neighbor_v4,
+		                 neighbor_v6,
+		                 neighbor_mac_address_v4,
+		                 neighbor_mac_address_v6,
+		                 next_module == "controlPlane" ? std::string("linux") : next_module);
 	}
 
-	table.print();
+	table.Print();
 }
 
 void lookup(const std::string& route_name,
@@ -66,25 +56,25 @@ void lookup(const std::string& route_name,
 	interface::controlPlane controlplane;
 	auto response = controlplane.route_lookup({route_name, address});
 
-	table_t table;
-	table.insert("ingress_physical_ports",
-	             "prefix",
-	             "nexthop",
-	             "egress_interface",
-	             "labels");
+	TablePrinter table;
+	table.insert_row("ingress_physical_ports",
+	                 "prefix",
+	                 "nexthop",
+	                 "egress_interface",
+	                 "labels");
 
 	for (const auto& item : response)
 	{
 		const auto& [ingress_physical_ports, prefix, nexthop, egress_interface, labels] = item;
 
-		table.insert(ingress_physical_ports,
-		             prefix,
-		             nexthop.is_default() ? std::string("") : nexthop.toString(),
-		             egress_interface,
-		             labels);
+		table.insert_row(ingress_physical_ports,
+		                 prefix,
+		                 nexthop.is_default() ? std::string("") : nexthop.toString(),
+		                 egress_interface,
+		                 labels);
 	}
 
-	table.print();
+	table.Print();
 }
 
 void get(const std::string& route_name,
@@ -93,24 +83,24 @@ void get(const std::string& route_name,
 	interface::controlPlane controlplane;
 	auto response = controlplane.route_get({route_name, prefix});
 
-	table_t table;
-	table.insert("ingress_physical_ports",
-	             "nexthop",
-	             "egress_interface",
-	             "labels");
+	TablePrinter table;
+	table.insert_row("ingress_physical_ports",
+	                 "nexthop",
+	                 "egress_interface",
+	                 "labels");
 
 	for (const auto& item : response)
 	{
 		const auto& [ingress_physical_ports, prefix, nexthop, egress_interface, labels] = item;
-		(void)prefix;
+		YANET_GCC_BUG_UNUSED(prefix);
 
-		table.insert(ingress_physical_ports,
-		             nexthop.is_default() ? std::string("") : nexthop.toString(),
-		             egress_interface,
-		             labels);
+		table.insert_row(ingress_physical_ports,
+		                 nexthop.is_default() ? std::string("") : nexthop.toString(),
+		                 egress_interface,
+		                 labels);
 	}
 
-	table.print();
+	table.Print();
 }
 
 void counters()
@@ -118,19 +108,7 @@ void counters()
 	interface::controlPlane controlplane;
 	auto response = controlplane.route_counters();
 
-	table_t table;
-	table.insert("link",
-	             "nexthop",
-	             "prefix",
-	             "counts",
-	             "size");
-
-	for (const auto& [link, nexthop, prefix, counts, size] : response)
-	{
-		table.insert(link, nexthop, prefix, counts, size);
-	}
-
-	table.print();
+	FillAndPrintTable({"link", "nexthop", "prefix", "counts", "size"}, response);
 }
 
 namespace tunnel
@@ -142,35 +120,29 @@ void lookup(const std::string& route_name,
 	interface::controlPlane controlplane;
 	auto response = controlplane.route_tunnel_lookup({route_name, address});
 
-	table_t table;
-	table.insert("ingress_physical_ports",
-	             "prefix",
-	             "nexthop",
-	             "label",
-	             "egress_interface",
-	             "peer",
-	             "weight (%)");
+	TablePrinter table;
+	table.insert_row("ingress_physical_ports",
+	                 "prefix",
+	                 "nexthop",
+	                 "label",
+	                 "egress_interface",
+	                 "peer",
+	                 "weight (%)");
 
 	for (const auto& item : response)
 	{
 		const auto& [ingress_physical_ports, prefix, nexthop, label, egress_interface, peer, weight_percent] = item;
 
-		double percent = (double)100.0 * weight_percent;
-
-		std::stringstream stream;
-		stream << std::fixed << std::setprecision(2) << percent;
-		std::string percent_string = stream.str();
-
-		table.insert(ingress_physical_ports,
-		             prefix,
-		             nexthop.is_default() ? std::string("") : nexthop.toString(),
-		             label,
-		             egress_interface,
-		             peer,
-		             percent_string);
+		table.insert_row(ingress_physical_ports,
+		                 prefix,
+		                 nexthop.is_default() ? std::string("") : nexthop.toString(),
+		                 label,
+		                 egress_interface,
+		                 peer,
+		                 utils::to_percent(weight_percent));
 	}
 
-	table.print();
+	table.Print();
 }
 
 void get(const std::string& route_name,
@@ -179,34 +151,28 @@ void get(const std::string& route_name,
 	interface::controlPlane controlplane;
 	auto response = controlplane.route_tunnel_get({route_name, prefix});
 
-	table_t table;
-	table.insert("ingress_physical_ports",
-	             "nexthop",
-	             "label",
-	             "egress_interface",
-	             "peer",
-	             "weight (%)");
+	TablePrinter table;
+	table.insert_row("ingress_physical_ports",
+	                 "nexthop",
+	                 "label",
+	                 "egress_interface",
+	                 "peer",
+	                 "weight (%)");
 
 	for (const auto& item : response)
 	{
 		const auto& [ingress_physical_ports, prefix, nexthop, label, egress_interface, peer, weight_percent] = item;
-		(void)prefix;
-
-		double percent = (double)100.0 * weight_percent;
-
-		std::stringstream stream;
-		stream << std::fixed << std::setprecision(2) << percent;
-		std::string percent_string = stream.str();
-
-		table.insert(ingress_physical_ports,
-		             nexthop.is_default() ? std::string("") : nexthop.toString(),
-		             label,
-		             egress_interface,
-		             peer,
-		             percent_string);
+		YANET_GCC_BUG_UNUSED(prefix);
+
+		table.insert_row(ingress_physical_ports,
+		                 nexthop.is_default() ? std::string("") : nexthop.toString(),
+		                 label,
+		                 egress_interface,
+		                 peer,
+		                 utils::to_percent(weight_percent));
 	}
 
-	table.print();
+	table.Print();
 }
 
 void counters()
@@ -214,18 +180,7 @@ void counters()
 	interface::controlPlane controlplane;
 	auto response = controlplane.route_tunnel_counters();
 
-	table_t table;
-	table.insert("link",
-	             "nexthop",
-	             "counts",
-	             "size");
-
-	for (const auto& [link, nexthop, counts, size] : response)
-	{
-		table.insert(link, nexthop, counts, size);
-	}
-
-	table.print();
+	FillAndPrintTable({"link", "nexthop", "counts", "size"}, response);
 }
 }
 
diff --git a/cli/show.h b/cli/show.h
index 6de4f7ca..41eafde2 100644
--- a/cli/show.h
+++ b/cli/show.h
@@ -11,6 +11,7 @@
 #include "common/version.h"
 
 #include "helper.h"
+#include "table_printer.h"
 
 namespace show
 {
@@ -20,35 +21,35 @@ inline void physicalPort()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.getPhysicalPorts();
 
-	table_t table;
-	table.insert("moduleName",
-	             "link",
-	             "speed",
-	             "rx_packets",
-	             "rx_bytes",
-	             "rx_errors",
-	             "rx_drops",
-	             "tx_packets",
-	             "tx_bytes",
-	             "tx_errors",
-	             "tx_drops");
+	TablePrinter table;
+	table.insert_row("moduleName",
+	                 "link",
+	                 "speed",
+	                 "rx_packets",
+	                 "rx_bytes",
+	                 "rx_errors",
+	                 "rx_drops",
+	                 "tx_packets",
+	                 "tx_bytes",
+	                 "tx_errors",
+	                 "tx_drops");
 
 	for (const auto& [physicalPortName, physicalPort] : response)
 	{
-		table.insert(physicalPortName,
-		             std::get<8>(physicalPort) ? "up" : "down",
-		             std::to_string(std::get<9>(physicalPort) / 1000) + "G",
-		             std::get<0>(physicalPort),
-		             std::get<1>(physicalPort),
-		             std::get<2>(physicalPort),
-		             std::get<3>(physicalPort),
-		             std::get<4>(physicalPort),
-		             std::get<5>(physicalPort),
-		             std::get<6>(physicalPort),
-		             std::get<7>(physicalPort));
+		table.insert_row(physicalPortName,
+		                 std::get<8>(physicalPort) ? "up" : "down",
+		                 std::to_string(std::get<9>(physicalPort) / 1000) + "G",
+		                 std::get<0>(physicalPort),
+		                 std::get<1>(physicalPort),
+		                 std::get<2>(physicalPort),
+		                 std::get<3>(physicalPort),
+		                 std::get<4>(physicalPort),
+		                 std::get<5>(physicalPort),
+		                 std::get<6>(physicalPort),
+		                 std::get<7>(physicalPort));
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void physical_port_dump(const std::string& direction,
@@ -75,23 +76,23 @@ inline void logicalPort()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.getLogicalPorts();
 
-	table_t table;
-	table.insert("moduleName",
-	             "physicalPortName",
-	             "vlanId",
-	             "macAddress",
-	             "promiscuousMode");
+	TablePrinter table;
+	table.insert_row("moduleName",
+	                 "physicalPortName",
+	                 "vlanId",
+	                 "macAddress",
+	                 "promiscuousMode");
 
 	for (const auto& [logicalPortName, logicalPort] : response)
 	{
-		table.insert(logicalPortName,
-		             std::get<0>(logicalPort),
-		             std::get<1>(logicalPort),
-		             std::get<2>(logicalPort),
-		             std::get<3>(logicalPort) ? "true" : "false");
+		table.insert_row(logicalPortName,
+		                 std::get<0>(logicalPort),
+		                 std::get<1>(logicalPort),
+		                 std::get<2>(logicalPort),
+		                 std::get<3>(logicalPort) ? "true" : "false");
 	}
 
-	table.print();
+	table.Print();
 }
 
 static inline std::string convertToString(const common::defender::status& status)
@@ -142,12 +143,12 @@ inline void summary(std::optional<std::string> module)
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.tun64_tunnels();
 
-	table_t table;
-	table.insert("module",
-	             "source_address",
-	             "prefixes",
-	             "randomization",
-	             "next_module");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "source_address",
+	                 "prefixes",
+	                 "randomization",
+	                 "next_module");
 
 	for (const auto& [tunnelName, tunnel] : response)
 	{
@@ -159,14 +160,14 @@ inline void summary(std::optional<std::string> module)
 
 		const auto& [ipv6Src, pfxCnt, rndFlag, nxtModule] = tunnel;
 
-		table.insert(tunnelName,
-		             ipv6Src,
-		             pfxCnt,
-		             rndFlag ? "true" : "false",
-		             nxtModule);
+		table.insert_row(tunnelName,
+		                 ipv6Src,
+		                 pfxCnt,
+		                 rndFlag ? "true" : "false",
+		                 nxtModule);
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void announce(std::optional<std::string> module)
@@ -174,10 +175,10 @@ inline void announce(std::optional<std::string> module)
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.tun64_prefixes();
 
-	table_t table;
-	table.insert("module",
-	             "prefix",
-	             "announces");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "prefix",
+	                 "announces");
 
 	for (const auto& [tunnelName, prefixes] : response)
 	{
@@ -189,11 +190,11 @@ inline void announce(std::optional<std::string> module)
 
 		for (const auto& prefix : prefixes)
 		{
-			table.insert(tunnelName, prefix, prefix);
+			table.insert_row(tunnelName, prefix, prefix);
 		}
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void mappings(std::optional<std::string> module)
@@ -201,11 +202,11 @@ inline void mappings(std::optional<std::string> module)
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.tun64_mappings();
 
-	table_t table;
-	table.insert("module",
-	             "ipv4Address",
-	             "ipv6Address",
-	             "location");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "ipv4Address",
+	                 "ipv6Address",
+	                 "location");
 
 	for (const auto& v : response)
 	{
@@ -217,13 +218,13 @@ inline void mappings(std::optional<std::string> module)
 			continue;
 		}
 
-		table.insert(tunnelName,
-		             ipv4Address,
-		             ipv6Address,
-		             location);
+		table.insert_row(tunnelName,
+		                 ipv4Address,
+		                 ipv6Address,
+		                 location);
 	}
 
-	table.print();
+	table.Print();
 }
 } /* namespace tun64 */
 
@@ -235,11 +236,11 @@ inline void summary()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.getDecaps();
 
-	table_t table;
-	table.insert("module",
-	             "prefixes",
-	             "DSCP",
-	             "next_module");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "prefixes",
+	                 "DSCP",
+	                 "next_module");
 
 	for (const auto& [decapName, decap] : response)
 	{
@@ -261,13 +262,13 @@ inline void summary()
 			dscpString = "n/s";
 		}
 
-		table.insert(decapName,
-		             std::get<0>(decap),
-		             dscpString,
-		             std::get<2>(decap));
+		table.insert_row(decapName,
+		                 std::get<0>(decap),
+		                 dscpString,
+		                 std::get<2>(decap));
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void announce()
@@ -275,22 +276,22 @@ inline void announce()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.getDecapPrefixes();
 
-	table_t table;
-	table.insert("module",
-	             "prefix",
-	             "announces");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "prefix",
+	                 "announces");
 
 	for (const auto& [moduleName, prefixes] : response)
 	{
 		for (const auto& prefix : prefixes)
 		{
-			table.insert(moduleName,
-			             prefix.prefix,
-			             prefix.announces);
+			table.insert_row(moduleName,
+			                 prefix.prefix,
+			                 prefix.announces);
 		}
 	}
 
-	table.print();
+	table.Print();
 }
 
 }
@@ -303,25 +304,25 @@ inline void summary()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.getNat64statelesses();
 
-	table_t table;
-	table.insert("module",
-	             "translations",
-	             "WKP",
-	             "SRC",
-	             "prefixes",
-	             "next_module");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "translations",
+	                 "WKP",
+	                 "SRC",
+	                 "prefixes",
+	                 "next_module");
 
 	for (const auto& [nat64statelessName, nat64stateless] : response)
 	{
-		table.insert(nat64statelessName,
-		             std::get<0>(nat64stateless),
-		             std::get<1>(nat64stateless),
-		             std::get<2>(nat64stateless),
-		             std::get<3>(nat64stateless),
-		             std::get<4>(nat64stateless));
+		table.insert_row(nat64statelessName,
+		                 std::get<0>(nat64stateless),
+		                 std::get<1>(nat64stateless),
+		                 std::get<2>(nat64stateless),
+		                 std::get<3>(nat64stateless),
+		                 std::get<4>(nat64stateless));
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void translation()
@@ -329,13 +330,13 @@ inline void translation()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.getNat64statelessTranslations();
 
-	table_t table;
-	table.insert("moduleName",
-	             "ipv6Address",
-	             "ipv6DestinationAddress",
-	             "fromRange",
-	             "ipv4Address",
-	             "toRange");
+	TablePrinter table;
+	table.insert_row("moduleName",
+	                 "ipv6Address",
+	                 "ipv6DestinationAddress",
+	                 "fromRange",
+	                 "ipv4Address",
+	                 "toRange");
 
 	for (const auto& [key, value] : response)
 	{
@@ -346,15 +347,15 @@ inline void translation()
 		const auto& ipv4Address = std::get<0>(value);
 		const auto& egressPorts = std::get<1>(value);
 
-		table.insert(moduleName,
-		             ipv6Address,
-		             ipv6DestinationAddress,
-		             ingressPorts,
-		             ipv4Address,
-		             egressPorts);
+		table.insert_row(moduleName,
+		                 ipv6Address,
+		                 ipv6DestinationAddress,
+		                 ingressPorts,
+		                 ipv4Address,
+		                 egressPorts);
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void announce()
@@ -362,10 +363,10 @@ inline void announce()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.getNat64statelessPrefixes();
 
-	table_t table;
-	table.insert("module",
-	             "prefix",
-	             "announces");
+	TablePrinter table;
+	table.insert_row("module",
+	                 "prefix",
+	                 "announces");
 
 	for (const auto& [moduleName, prefixes] : response)
 	{
@@ -373,15 +374,15 @@ inline void announce()
 		{
 			std::visit(
 			        [&, &moduleName = moduleName](auto&& value) {
-				        table.insert(moduleName,
-				                     value.prefix,
-				                     value.announces);
+				        table.insert_row(moduleName,
+				                         value.prefix,
+				                         value.announces);
 			        },
 			        (const common::ip_prefix_with_announces_t::variant_t&)prefix);
 		}
 	}
 
-	table.print();
+	table.Print();
 }
 
 }
@@ -509,21 +510,21 @@ static void list_fw_rules(unsigned int mask, bool list)
 	common::icp::getFwLabels::response labels;
 	interface::controlPlane controlPlane;
 
-	table_t table;
+	TablePrinter table;
 	if (list)
 	{
-		table.insert("id",
-		             "ruleno",
-		             "label",
-		             "rule");
+		table.insert_row("id",
+		                 "ruleno",
+		                 "label",
+		                 "rule");
 	}
 	else
 	{
-		table.insert("id",
-		             "ruleno",
-		             "label",
-		             "counter",
-		             "rule");
+		table.insert_row("id",
+		                 "ruleno",
+		                 "label",
+		                 "counter",
+		                 "rule");
 	}
 
 	if (need_labels & mask)
@@ -578,17 +579,17 @@ static void list_fw_rules(unsigned int mask, bool list)
 			{
 				if (list)
 				{
-					(void)counter;
-					table.insert(id, ruleno, label, text);
+					YANET_GCC_BUG_UNUSED(counter);
+					table.insert_row(id, ruleno, label, text);
 				}
 				else
 				{
-					table.insert(id, ruleno, label, counter, text);
+					table.insert_row(id, ruleno, label, counter, text);
 				}
 			}
 		}
 	}
-	table.print();
+	table.Print();
 }
 
 inline void fw(std::optional<std::string> str)
@@ -625,18 +626,10 @@ inline void fwlist(std::optional<std::string> str)
 
 inline void errors()
 {
-	table_t table;
-	table.insert("name", "counter");
-
 	interface::dataPlane dataPlane;
 	const auto response = dataPlane.getErrors();
 
-	for (const auto& [name, counter] : response)
-	{
-		table.insert(name, counter);
-	}
-
-	table.print();
+	FillAndPrintTable({"name", "counter"}, response);
 }
 
 inline void samples()
@@ -644,14 +637,14 @@ inline void samples()
 	interface::controlPlane controlPlane;
 	const auto response = controlPlane.getSamples();
 
-	table_t table;
-	table.insert("in_iface",
-	             "out_iface",
-	             "proto",
-	             "src_addr",
-	             "src_port",
-	             "dst_addr",
-	             "dst_port");
+	TablePrinter table;
+	table.insert_row("in_iface",
+	                 "out_iface",
+	                 "proto",
+	                 "src_addr",
+	                 "src_port",
+	                 "dst_addr",
+	                 "dst_port");
 
 	// Cache the protocols we are interested in to prevent enormous number of reading of "/etc/protocols".
 	std::unordered_map<std::uint8_t, std::string> proto_cache;
@@ -671,10 +664,10 @@ inline void samples()
 		}
 		const auto& protoName = it->second;
 
-		table.insert(in_iface, out_iface, protoName, src_addr, src_port, dst_addr, dst_port);
+		table.insert_row(in_iface, out_iface, protoName, src_addr, src_port, dst_addr, dst_port);
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void samples_dump()
@@ -693,12 +686,12 @@ inline void samples_dump()
 		}
 		first = false;
 		std::cout << "\n"
-		          << "{\"in_iface\":\"" << in_iface << "\","
-		          << "\"out_iface\":\"" << out_iface << "\","
+		          << R"({"in_iface":")" << in_iface << "\","
+		          << R"("out_iface":")" << out_iface << "\","
 		          << "\"proto\":" << (int)proto << ","
-		          << "\"src_addr\":\"" << src_addr.toString() << "\","
+		          << R"("src_addr":")" << src_addr.toString() << "\","
 		          << "\"src_port\":" << src_port << ","
-		          << "\"dst_addr\":\"" << dst_addr.toString() << "\","
+		          << R"("dst_addr":")" << dst_addr.toString() << "\","
 		          << "\"dst_port\":" << dst_port << "}";
 	}
 
@@ -710,19 +703,19 @@ inline void values()
 	interface::controlPlane controlplane;
 	const auto controlplane_values = controlplane.controlplane_values();
 
-	table_t table;
-	table.insert("application",
-	             "name",
-	             "value");
+	TablePrinter table;
+	table.insert_row("application",
+	                 "name",
+	                 "value");
 
 	for (const auto& [name, value] : controlplane_values)
 	{
-		table.insert("controlplane",
-		             name,
-		             value);
+		table.insert_row("controlplane",
+		                 name,
+		                 value);
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void durations()
@@ -730,29 +723,29 @@ inline void durations()
 	interface::controlPlane controlplane;
 	const auto controlplane_durations = controlplane.controlplane_durations();
 
-	table_t table;
-	table.insert("application",
-	             "name",
-	             "duration");
+	TablePrinter table;
+	table.insert_row("application",
+	                 "name",
+	                 "duration");
 
 	for (const auto& [name, value] : controlplane_durations)
 	{
-		table.insert("controlplane",
-		             name,
-		             value);
+		table.insert_row("controlplane",
+		                 name,
+		                 value);
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void version()
 {
-	table_t table;
-	table.insert("application",
-	             "version",
-	             "revision",
-	             "hash",
-	             "custom");
+	TablePrinter table;
+	table.insert_row("application",
+	                 "version",
+	                 "revision",
+	                 "hash",
+	                 "custom");
 
 	/// dataplane
 	try
@@ -760,11 +753,11 @@ inline void version()
 		interface::dataPlane dataplane;
 		const auto [major, minor, revision, hash, custom] = dataplane.version();
 
-		table.insert("dataplane",
-		             version_to_string(major, minor),
-		             version_revision_to_string(revision),
-		             version_hash_to_string(hash),
-		             version_custom_to_string(custom));
+		table.insert_row("dataplane",
+		                 version_to_string(major, minor),
+		                 version_revision_to_string(revision),
+		                 version_hash_to_string(hash),
+		                 version_custom_to_string(custom));
 	}
 	catch (...)
 	{
@@ -776,11 +769,11 @@ inline void version()
 		interface::controlPlane controlplane;
 		const auto [major, minor, revision, hash, custom] = controlplane.version();
 
-		table.insert("controlplane",
-		             version_to_string(major, minor),
-		             version_revision_to_string(revision),
-		             version_hash_to_string(hash),
-		             version_custom_to_string(custom));
+		table.insert_row("controlplane",
+		                 version_to_string(major, minor),
+		                 version_revision_to_string(revision),
+		                 version_hash_to_string(hash),
+		                 version_custom_to_string(custom));
 	}
 	catch (...)
 	{
@@ -788,14 +781,14 @@ inline void version()
 
 	/// cli
 	{
-		table.insert("cli",
-		             version_to_string(),
-		             version_revision_to_string(),
-		             version_hash_to_string(),
-		             version_custom_to_string());
+		table.insert_row("cli",
+		                 version_to_string(),
+		                 version_revision_to_string(),
+		                 version_hash_to_string(),
+		                 version_custom_to_string());
 	}
 
-	table.print();
+	table.Print();
 }
 
 inline void counter_by_name(std::string counter_name,
@@ -815,16 +808,7 @@ inline void counter_by_name(std::string counter_name,
 		}
 	}
 
-	table_t table;
-	table.insert("core_id",
-	             "counter_value");
-
-	for (const auto& [core_id, counter_value] : response)
-	{
-		table.insert(core_id, counter_value);
-	}
-
-	table.print();
+	FillAndPrintTable({"core_id", "counter_value"}, response);
 }
 
 inline void shm_info()
@@ -832,22 +816,15 @@ inline void shm_info()
 	interface::dataPlane dataplane;
 	const auto response = dataplane.get_shm_info();
 
-	table_t table;
-	table.insert("ring name",
-	             "dump tag",
-	             "dump size",
-	             "dump count",
-	             "core id",
-	             "socket id",
-	             "ipc key",
-	             "offset");
-
-	for (const auto& [name, tag, size, count, core, socket, ipc_key, offset] : response)
-	{
-		table.insert(name, tag, size, count, core, socket, ipc_key, offset);
-	}
-
-	table.print();
+	FillAndPrintTable({"ring name",
+	                   "dump tag",
+	                   "dump size",
+	                   "dump count",
+	                   "core id",
+	                   "socket id",
+	                   "ipc key",
+	                   "offset"},
+	                  response);
 }
 
 void shm_tsc_info()
@@ -855,18 +832,7 @@ void shm_tsc_info()
 	interface::dataPlane dataplane;
 	const auto response = dataplane.get_shm_tsc_info();
 
-	table_t table;
-	table.insert("core id",
-	             "socket id",
-	             "ipc key",
-	             "offset");
-
-	for (const auto& [core, socket, ipc_key, offset] : response)
-	{
-		table.insert(core, socket, ipc_key, offset);
-	}
-
-	table.print();
+	FillAndPrintTable({"core id", "socket id", "ipc key", "offset"}, response);
 }
 
 void shm_tsc_set_state(bool state)
diff --git a/cli/table_printer.h b/cli/table_printer.h
new file mode 100644
index 00000000..9ef8d01f
--- /dev/null
+++ b/cli/table_printer.h
@@ -0,0 +1,316 @@
+#pragma once
+
+#include <iostream>
+#include <nlohmann/json.hpp>
+#include <string>
+
+#include "common/utils.h"
+#include "converter.h"
+
+class TablePrinter
+{
+public:
+	TablePrinter(const converter::config_t config = {}) :
+	        config_(config) {}
+
+	// Insert arbitrary number of values as one row
+	template<typename... Args>
+	void insert_row(Args&&... args)
+	{
+		insert_row({converter::to_string(std::forward<Args>(args), config_)...});
+	}
+
+	// Insert tuple as one row
+	template<typename... Args>
+	void insert_row(const std::tuple<Args...>& tuple)
+	{
+		std::vector<std::string> row;
+
+		std::apply([&row, this](const Args&... args) {
+			(row.push_back(converter::to_string(args, config_)), ...);
+		},
+		           tuple);
+
+		insert_row(std::move(row));
+	}
+
+	// Insert pair as one row
+	template<typename First, typename Second>
+	void insert_row(const std::pair<First, Second>& pair)
+	{
+		std::vector<std::string> row;
+		row.push_back(converter::to_string(pair.first, config_));
+		row.push_back(converter::to_string(pair.second, config_));
+
+		insert_row(std::move(row));
+	}
+
+	// Insert values from a container as one row
+	template<typename Iterator, typename = typename std::iterator_traits<Iterator>::iterator_category>
+	void insert_row(Iterator begin, Iterator end)
+	{
+		std::vector<std::string> row;
+		for (auto it = begin; it != end; ++it)
+		{
+			row.push_back(converter::to_string(*it, config_));
+		}
+		insert_row(std::move(row));
+	}
+
+	/**
+	 * Insert values from a container as many rows
+	 *
+	 * Useful when we have a container of containers like the "responce"
+	 * object obtained from controlplane
+	 */
+	template<typename Iterator, typename = typename std::iterator_traits<Iterator>::iterator_category>
+	void insert(Iterator begin, Iterator end)
+	{
+		for (auto it = begin; it != end; ++it)
+		{
+			insert_row(*it);
+		}
+	}
+
+	void Print()
+	{
+		std::string format;
+		if (const char* format_pointer = std::getenv("YANET_FORMAT"))
+		{
+			format = format_pointer;
+		}
+
+		(format == "json") ? print_json() : print_default();
+	}
+
+	void Render()
+	{
+		std::cout << "\033[H\033[2J" << std::flush;
+
+		print_default();
+		table_.clear();
+	}
+
+private:
+	void insert_row(std::vector<std::string>&& row)
+	{
+		if (row.size() > column_lengths_.size())
+		{
+			column_lengths_.resize(row.size(), 0);
+		}
+
+		for (uint32_t i = 0; i < row.size(); ++i)
+		{
+			if (column_lengths_[i] < row[i].size())
+			{
+				column_lengths_[i] = row[i].size();
+			}
+		}
+
+		table_.push_back(std::move(row));
+	}
+
+	void print_default()
+	{
+		if (table_.empty() || column_lengths_.empty())
+		{
+			return;
+		}
+
+		std::vector<std::string> user_selected_col_names;
+		if (const char* columns_pointer = std::getenv("YANET_FORMAT_COLUMNS"))
+		{
+			user_selected_col_names = utils::split(columns_pointer, ',');
+		}
+
+		bool print_selected_cols_only = !user_selected_col_names.empty();
+
+		// The header row contains the table's column names
+		const auto& header_row = table_.front();
+
+		/*
+		 * If the user has specified certain columns to be printed in a specific order,
+		 * we need to map each column's index from the user-provided list to its corresponding
+		 * index in the table.
+		 * If no specific column selection or order is provided by the user,
+		 * print all columns in the default table order:
+		 */
+		std::unordered_map<std::string, size_t> header_indices;
+		for (size_t idx = 0; idx < header_row.size(); ++idx)
+		{
+			header_indices[header_row[idx]] = idx;
+		}
+
+		std::vector<size_t> columns_order;
+		if (print_selected_cols_only)
+		{
+			for (const auto& col_name : user_selected_col_names)
+			{
+				auto it = header_indices.find(col_name);
+				if (it != header_indices.end())
+				{
+					columns_order.push_back(it->second);
+				}
+				else
+				{
+					std::cerr << "The column name '" << col_name
+					          << "' in YANET_FORMAT_COLUMNS does not match any "
+					          << "available column name. Skipping it." << std::endl;
+					std::cerr << "Available column names are: ";
+					for (auto it = header_row.begin(); it != header_row.end(); ++it)
+					{
+						std::cerr << *it;
+						if (std::next(it) != header_row.end())
+						{
+							std::cerr << ", ";
+						}
+					}
+					std::cerr << std::endl;
+				}
+			}
+		}
+		else
+		{
+			columns_order.resize(header_row.size());
+			std::iota(columns_order.begin(), columns_order.end(), 0);
+		}
+
+		if (columns_order.empty())
+		{
+			return;
+		}
+
+		print_row(header_row, columns_order, true);
+
+		for (size_t row_idx = 1; row_idx < table_.size(); ++row_idx)
+		{
+			const auto& row = table_[row_idx];
+			print_row(row, columns_order, false);
+		}
+	}
+
+	void print_json()
+	{
+		if (table_.empty())
+		{
+			return;
+		}
+
+		std::vector<std::string> format_keys;
+		if (const char* format_keys_pointer = std::getenv("YANET_FORMAT_KEYS"))
+		{
+			format_keys = utils::split(format_keys_pointer, ',');
+		}
+
+		// The header row contains the table's column names
+		const auto& header_row = table_.front();
+
+		// Build a mapping from column indices to format_keys indices
+		std::unordered_map<size_t, size_t> format_keys_i;
+		if (!format_keys.empty())
+		{
+			for (size_t idx = 0; idx < header_row.size(); ++idx)
+			{
+				auto it = std::find(format_keys.begin(), format_keys.end(), header_row[idx]);
+				if (it != format_keys.end())
+				{
+					size_t format_idx = std::distance(format_keys.begin(), it);
+					format_keys_i[idx] = format_idx;
+				}
+			}
+		}
+
+		nlohmann::json json_root;
+
+		// Process each data row
+		for (size_t row_idx = 1; row_idx < table_.size(); ++row_idx)
+		{
+			const auto& row = table_[row_idx];
+
+			std::vector<std::string> tree(format_keys.size());
+
+			nlohmann::json json_row;
+			for (size_t idx = 0; idx < row.size(); ++idx)
+			{
+				auto it = format_keys_i.find(idx);
+				if (it != format_keys_i.end())
+				{
+					// This column is part of the nested keys
+					size_t tree_idx = it->second;
+					tree[tree_idx] = row[idx];
+				}
+				else if (idx < header_row.size())
+				{
+					// Regular key-value pair in the row
+					json_row[header_row[idx]] = row[idx];
+				}
+			}
+
+			nlohmann::json* json_current = &json_root;
+			for (const auto& key : tree)
+			{
+				json_current = &((*json_current)[key]);
+			}
+
+			json_current->push_back(json_row);
+		}
+
+		std::cout << json_root.dump(2) << std::endl;
+	}
+
+	void print_row(const std::vector<std::string>& row,
+	               const std::vector<size_t>& columns_order,
+	               bool is_header)
+	{
+		for (size_t i = 0; i < columns_order.size(); ++i)
+		{
+			size_t col_idx = columns_order[i];
+			auto col_width = static_cast<int>(column_lengths_[col_idx]);
+			const auto& cell = row[col_idx];
+
+			if (i == 0)
+			{
+				std::cout << std::left << std::setw(col_width) << cell;
+			}
+			else
+			{
+				std::cout << "  "; // Add separation between columns
+				if (i != columns_order.size() - 1)
+				{
+					// For all but the last column, use setw
+					std::cout << std::left << std::setw(col_width) << cell;
+				}
+				else
+				{
+					// Do not pad the last column
+					std::cout << cell;
+				}
+			}
+		}
+		std::cout << '\n';
+
+		if (is_header)
+		{
+			// Print a separator line after the header
+			for (size_t i = 0; i < columns_order.size(); ++i)
+			{
+				size_t col_idx = columns_order[i];
+				auto col_width = column_lengths_[col_idx];
+
+				if (i == 0)
+				{
+					std::cout << std::string(col_width, '-');
+				}
+				else
+				{
+					std::cout << "  " << std::string(col_width, '-');
+				}
+			}
+			std::cout << '\n';
+		}
+	}
+
+	converter::config_t config_;
+	std::vector<std::vector<std::string>> table_;
+	std::vector<size_t> column_lengths_;
+};
diff --git a/cli/telegraf.h b/cli/telegraf.h
index f9e429a6..577d5f0a 100644
--- a/cli/telegraf.h
+++ b/cli/telegraf.h
@@ -27,8 +27,8 @@ void ports_stats()
 {
 	interface::dataPlane dataplane;
 	const auto [ports_cfg, cores_cfg, values] = dataplane.getConfig();
-	(void)cores_cfg;
-	(void)values;
+	YANET_GCC_BUG_UNUSED(cores_cfg);
+	YANET_GCC_BUG_UNUSED(values);
 
 	const std::vector<std::tuple<const char*, common::idp::port_stats_t>> ports_stats_per_type{
 	        {"port", dataplane.get_ports_stats()},
@@ -40,9 +40,9 @@ void ports_stats()
 		for (const auto& [port_id, stats] : ports_stats)
 		{
 			const auto& [interface_name, socket_id, eth_addr, pci] = ports_cfg.at(port_id);
-			(void)socket_id;
-			(void)eth_addr;
-			(void)pci;
+			YANET_GCC_BUG_UNUSED(socket_id);
+			YANET_GCC_BUG_UNUSED(eth_addr);
+			YANET_GCC_BUG_UNUSED(pci);
 			const auto& [rx_packets, rx_bytes, rx_errors, rx_drops, tx_packets, tx_bytes, tx_errors, tx_drops] = stats;
 
 			printf("%s,physicalPortName=%s "
@@ -453,7 +453,7 @@ void dregress()
 	std::map<common::community_t, std::string> communities;
 	for (const auto& [community, peer_link_orig] : communities_orig)
 	{
-		(void)peer_link_orig;
+		YANET_GCC_BUG_UNUSED(peer_link_orig);
 
 		uint32_t link_id = 0;
 
@@ -588,7 +588,7 @@ void other()
 	const auto& [flagFirst, workers, ports] = controlPlane.telegraf_other();
 	const auto rib_summary = controlPlane.rib_summary();
 	const auto limit_summary = controlPlane.limit_summary();
-	(void)flagFirst;
+	YANET_GCC_BUG_UNUSED(flagFirst);
 
 	for (const auto& workerIter : workers)
 	{
@@ -667,7 +667,7 @@ void service()
 
 		for (const auto& [virtual_ip, proto, virtual_port, nap_connections, packets, bytes, real_disabled_packets, real_disabled_bytes] : services)
 		{
-			(void)nap_connections;
+			YANET_GCC_BUG_UNUSED(nap_connections);
 
 			common::idp::balancer_service_connections::service_key_t key = {module_id,
 			                                                                virtual_ip,
@@ -677,7 +677,7 @@ void service()
 			uint32_t connections = 0;
 			for (auto& [socket_id, service_connections] : balancer_service_connections)
 			{
-				(void)socket_id;
+				YANET_GCC_BUG_UNUSED(socket_id);
 
 				const auto& socket_connections = service_connections[key].value;
 				if (socket_connections > connections)
@@ -710,8 +710,8 @@ void main_counters()
 	for (const auto& [coreId, worker_info] : sdp_data.workers)
 	{
 		std::vector<influxdb_format::value_t> values;
-		uint64_t* buffer = common::sdp::ShiftBuffer<uint64_t*>(worker_info.buffer,
-		                                                       sdp_data.metadata_worker.start_counters);
+		auto* buffer = common::sdp::ShiftBuffer<uint64_t*>(worker_info.buffer,
+		                                                   sdp_data.metadata_worker.start_counters);
 		for (const auto& [name, index] : sdp_data.metadata_worker.counter_positions)
 		{
 			values.emplace_back(name.data(), buffer[index]);
@@ -722,8 +722,8 @@ void main_counters()
 	for (const auto& [coreId, worker_info] : sdp_data.workers_gc)
 	{
 		std::vector<influxdb_format::value_t> values;
-		uint64_t* buffer = common::sdp::ShiftBuffer<uint64_t*>(worker_info.buffer,
-		                                                       sdp_data.metadata_worker.start_counters);
+		auto* buffer = common::sdp::ShiftBuffer<uint64_t*>(worker_info.buffer,
+		                                                   sdp_data.metadata_worker.start_counters);
 		for (const auto& [name, index] : sdp_data.metadata_worker_gc.counter_positions)
 		{
 			values.emplace_back(name.data(), buffer[index]);
diff --git a/cli/unittest/call.cpp b/cli/unittest/call.cpp
new file mode 100644
index 00000000..f16cc5cb
--- /dev/null
+++ b/cli/unittest/call.cpp
@@ -0,0 +1,155 @@
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include "cli/helper.h"
+
+namespace
+{
+
+class CallableClass
+{
+public:
+	void operator()(int a, std::optional<double> b, const std::string& c) const
+	{
+		EXPECT_EQ(a, 70);
+		if (b.has_value())
+		{
+			EXPECT_DOUBLE_EQ(b.value(), 45.67);
+		}
+		EXPECT_EQ(c, "test");
+	}
+};
+
+void CheckIntegerAndString(int a, const std::string& str)
+{
+	EXPECT_EQ(a, 42);
+	EXPECT_EQ(str, "hello");
+}
+
+void CheckOptionalIntegerAndStringPresent(int a, std::optional<int> b, const std::string& str)
+{
+	EXPECT_EQ(a, 42);
+	EXPECT_TRUE(b.has_value());
+	EXPECT_EQ(b.value(), 100);
+	EXPECT_EQ(str, "world");
+}
+
+void CheckOptionalIntegerMissing(int a, std::optional<int> b, const std::string& str)
+{
+	EXPECT_EQ(a, 42);
+	EXPECT_FALSE(b.has_value());
+	EXPECT_EQ(str, "world");
+}
+
+void CheckBooleanTrueAndOptionalString(bool flag, std::optional<std::string> text)
+{
+	EXPECT_TRUE(flag);
+	EXPECT_TRUE(text.has_value());
+	EXPECT_EQ(text.value(), "some_text");
+}
+
+void CheckBooleanFalseAndMissingOptionalString(bool flag, std::optional<std::string> text)
+{
+	EXPECT_FALSE(flag);
+	EXPECT_FALSE(text.has_value());
+}
+
+void CheckCallableClassWithOptional(int a, std::optional<double> b, const std::string& c)
+{
+	EXPECT_EQ(a, 70);
+	EXPECT_TRUE(b.has_value());
+	EXPECT_DOUBLE_EQ(b.value(), 45.67);
+	EXPECT_EQ(c, "test");
+}
+
+void CheckCallableClassWithMissingOptional(int a, std::optional<double> b, const std::string& c)
+{
+	EXPECT_EQ(a, 70);
+	EXPECT_FALSE(b.has_value());
+	EXPECT_EQ(c, "test");
+}
+
+TEST(CallFunctionTests, IntegerAndString)
+{
+	std::vector<std::string> args = {"42", "hello"};
+	EXPECT_NO_THROW(Call(CheckIntegerAndString, args));
+}
+
+TEST(CallFunctionTests, OptionalIntegerPresent)
+{
+	std::vector<std::string> args = {"42", "100", "world"};
+	EXPECT_NO_THROW(Call(CheckOptionalIntegerAndStringPresent, args));
+}
+
+TEST(CallFunctionTests, OptionalIntegerMissing)
+{
+	std::vector<std::string> args = {"42", "", "world"};
+	EXPECT_NO_THROW(Call(CheckOptionalIntegerMissing, args));
+}
+
+TEST(CallFunctionTests, BooleanTrueAndOptionalStringPresent)
+{
+	std::vector<std::string> args = {"true", "some_text"};
+	EXPECT_NO_THROW(Call(CheckBooleanTrueAndOptionalString, args));
+}
+
+TEST(CallFunctionTests, BooleanFalseAndMissingOptionalString)
+{
+	std::vector<std::string> args = {"false", ""};
+	EXPECT_NO_THROW(Call(CheckBooleanFalseAndMissingOptionalString, args));
+}
+
+TEST(CallFunctionTests, CallableClassWithOptional)
+{
+	std::vector<std::string> args = {"70", "45.67", "test"};
+	EXPECT_NO_THROW(Call(CheckCallableClassWithOptional, args));
+}
+
+TEST(CallFunctionTests, CallableClassWithMissingOptional)
+{
+	std::vector<std::string> args = {"70", "", "test"};
+	EXPECT_NO_THROW(Call(CheckCallableClassWithMissingOptional, args));
+}
+
+TEST(CallFunctionTests, LambdaFunction_WithValidArguments)
+{
+	auto lambda = [](int x, std::optional<std::string> opt, bool flag) {
+		EXPECT_EQ(x, 50);
+		if (opt.has_value())
+		{
+			EXPECT_EQ(opt.value(), "optional_text");
+		}
+		EXPECT_TRUE(flag);
+	};
+
+	std::vector<std::string> args = {"50", "optional_text", "true"};
+	EXPECT_NO_THROW(Call(lambda, args));
+}
+
+TEST(CallFunctionTests, LambdaFunction_WithMissingOptional)
+{
+	auto lambda = [](int x, std::optional<std::string> opt, bool flag) {
+		EXPECT_EQ(x, 50);
+		EXPECT_FALSE(opt.has_value());
+		EXPECT_FALSE(flag);
+	};
+
+	std::vector<std::string> args = {"50", "", "false"};
+	EXPECT_NO_THROW(Call(lambda, args));
+}
+
+TEST(CallFunctionTests, CallableClass_WithValidArguments)
+{
+	CallableClass callable_object;
+	std::vector<std::string> args = {"70", "45.67", "test"};
+	EXPECT_NO_THROW(Call(callable_object, args));
+}
+
+TEST(CallFunctionTests, CallableClass_WithMissingOptional)
+{
+	CallableClass callable_object;
+	std::vector<std::string> args = {"70", "", "test"};
+	EXPECT_NO_THROW(Call(callable_object, args));
+}
+
+}
diff --git a/cli/unittest/meson.build b/cli/unittest/meson.build
new file mode 100644
index 00000000..49fd06d1
--- /dev/null
+++ b/cli/unittest/meson.build
@@ -0,0 +1,24 @@
+dependencies = []
+dependencies += libyanet_protobuf_dep
+dependencies += libjson.get_variable('nlohmann_json_dep')
+dependencies += dependency('threads')
+dependencies += dependency('gtest')
+dependencies += dependency('gtest_main')
+
+cli_sources = files()
+
+sources = files('unittest.cpp',
+                'call.cpp',
+                )
+
+unittest = executable('yanet-cli-unittest',
+                      [cli_sources, sources],
+                      include_directories: yanet_rootdir,
+                      dependencies: dependencies,
+                      cpp_args: cpp_args_append,
+                      override_options: 'b_lto=false')
+
+test('cli',
+     unittest,
+     protocol: 'gtest',
+     timeout: 300)
diff --git a/cli/unittest/unittest.cpp b/cli/unittest/unittest.cpp
new file mode 100644
index 00000000..40f635f4
--- /dev/null
+++ b/cli/unittest/unittest.cpp
@@ -0,0 +1,3 @@
+#include "common/define.h"
+
+inline common::log::LogPriority common::log::logPriority = common::log::TLOG_DEBUG;
diff --git a/common/acl.h b/common/acl.h
index fdc64871..f753e2ff 100644
--- a/common/acl.h
+++ b/common/acl.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "stream.h"
 #include "type.h"
 
 namespace common::acl
@@ -9,70 +8,56 @@ namespace common::acl
 class tree_value_t
 {
 public:
-	tree_value_t() :
-	        id(0)
-	{
-	}
+	tree_value_t() = default;
 
 	constexpr bool operator<(const tree_value_t& second) const
 	{
 		return id < second.id;
 	}
 
-	inline bool is_empty() const
+	[[nodiscard]] bool is_empty() const
 	{
 		return !id;
 	}
 
-	inline uint32_t get_group_id() const
+	[[nodiscard]] uint32_t get_group_id() const
 	{
 		return id;
 	}
 
-	inline void set_group_id(const uint32_t group_id)
+	void set_group_id(const uint32_t group_id)
 	{
 		id = group_id;
 	}
 
-	inline bool is_chunk_id() const
+	[[nodiscard]] bool is_chunk_id() const
 	{
 		return id & 0x80000000u;
 	}
 
-	inline uint32_t get_chunk_id() const
+	[[nodiscard]] uint32_t get_chunk_id() const
 	{
 		return id ^ 0x80000000u;
 	}
 
-	inline void set_chunk_id(const uint32_t chunk_id)
+	void set_chunk_id(const uint32_t chunk_id)
 	{
 		id = chunk_id ^ 0x80000000u;
 	}
 
 protected:
-	uint32_t id; ///< stored group_id or chunk_id
+	uint32_t id{}; ///< stored group_id or chunk_id
 };
 
 template<unsigned int bits = 8>
 class tree_chunk_t
 {
 public:
-	tree_chunk_t() :
-	        is_multirefs(0)
-	{
-	}
-
-	inline void pop(common::stream_in_t& stream)
-	{
-		stream.pop(values);
-	}
+	tree_chunk_t() = default;
 
-	inline void push(common::stream_out_t& stream) const
-	{
-		stream.push(values);
-	}
+	SERIALIZABLE(values);
 
-	uint8_t is_multirefs;
+	uint8_t is_multirefs{};
 	tree_value_t values[1u << bits];
 };
 
@@ -142,25 +127,17 @@ class range_t
 	}
 
 public:
-	inline type_t from() const
+	type_t from() const
 	{
 		return std::get<0>(from_to);
 	}
 
-	inline type_t to() const
+	type_t to() const
 	{
 		return std::get<1>(from_to);
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(from_to);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(from_to);
-	}
+	SERIALIZABLE(from_to);
 
 public:
 	std::tuple<type_t, type_t> from_to;
@@ -176,15 +153,7 @@ class ranges_t
 	}
 
 public:
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(vector);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(vector);
-	}
+	SERIALIZABLE(vector);
 
 	void insert_any()
 	{
diff --git a/common/actions.h b/common/actions.h
index 1eeee311..e7080bce 100644
--- a/common/actions.h
+++ b/common/actions.h
@@ -1,7 +1,7 @@
 #pragma once
 
+#include "common/traits.h"
 #include "common/type.h"
-#include "common/utils.h"
 #include "common/variant_trait_map.h"
 
 namespace common
@@ -39,17 +39,7 @@ class dump_t
 		       std::tie(o.dump_id, o.dump_tag);
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(dump_id);
-		stream.pop(dump_tag);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(dump_id);
-		stream.push(dump_tag);
-	}
+	SERIALIZABLE(dump_id, dump_tag);
 
 	uint64_t dump_id;
 	std::string dump_tag;
@@ -96,15 +86,7 @@ struct state_timeout_t
 		return timeout < o.timeout;
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(timeout);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(timeout);
-	}
+	SERIALIZABLE(timeout);
 
 	uint32_t timeout;
 };
@@ -135,15 +117,7 @@ struct DumpAction final
 
 	[[nodiscard]] bool terminating() const { return false; }
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(dump_id);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(dump_id);
-	}
+	SERIALIZABLE(dump_id);
 
 	[[nodiscard]] std::string to_string() const
 	{
@@ -178,17 +152,7 @@ struct FlowAction final
 
 	[[nodiscard]] bool terminating() const { return true; }
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(flow);
-		stream.pop(timeout);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(flow);
-		stream.push(timeout);
-	}
+	SERIALIZABLE(flow, timeout);
 
 	[[nodiscard]] std::string to_string() const
 	{
@@ -250,15 +214,7 @@ struct StateTimeoutAction final
 
 	[[nodiscard]] bool terminating() const { return false; }
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(timeout);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(timeout);
-	}
+	SERIALIZABLE(timeout);
 
 	[[nodiscard]] std::string to_string() const
 	{
@@ -284,19 +240,12 @@ struct Action
 	Action(T action) :
 	        raw_action(std::move(action)) {}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(raw_action);
-	}
-	void push(stream_out_t& stream) const
-	{
-		stream.push(raw_action);
-	}
-
 	[[nodiscard]] std::string to_string() const
 	{
 		return std::visit([](auto&& action) { return action.to_string(); }, raw_action);
 	}
+
+	SERIALIZABLE(raw_action);
 };
 
 namespace acl
@@ -470,11 +419,11 @@ struct IntermediateActions
 		}
 		else
 		{
-			static_assert(utils::always_false<T>::value, "Not all unique actions with MAX_COUNT = 1 are properly categorized. "
-			                                             "Please add the missing actions to either `is_first_matters` or `is_last_matters` "
-			                                             "to ensure their index is tracked. Tracking the index of such actions could "
-			                                             "enhance dataplane performance if this information is utilized in "
-			                                             "`value_t::compile()`.");
+			static_assert(traits::always_false_v<T>, "Not all unique actions with MAX_COUNT = 1 are properly categorized. "
+			                                         "Please add the missing actions to either `is_first_matters` or `is_last_matters` "
+			                                         "to ensure their index is tracked. Tracking the index of such actions could "
+			                                         "enhance dataplane performance if this information is utilized in "
+			                                         "`value_t::compile()`.");
 		}
 	}
 
@@ -611,15 +560,7 @@ class BaseActions<ActionsPath::Default>
 		return get_flow() < second.get_flow();
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(path_);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(path_);
-	}
+	SERIALIZABLE(path_);
 };
 
 template<>
@@ -670,17 +611,7 @@ class BaseActions<ActionsPath::WithCheckState> : public BaseActions<ActionsPath:
 		return check_state_path_.back().raw_action;
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(path_);
-		stream.pop(check_state_path_);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(path_);
-		stream.push(check_state_path_);
-	}
+	SERIALIZABLE(path_, check_state_path_);
 };
 
 /**
diff --git a/common/balancer.h b/common/balancer.h
index 132f5c1d..ae308414 100644
--- a/common/balancer.h
+++ b/common/balancer.h
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <inttypes.h>
-
+#include <cstdint>
 namespace balancer
 {
 
diff --git a/common/btree.h b/common/btree.h
index fcaff50a..e11c8e76 100644
--- a/common/btree.h
+++ b/common/btree.h
@@ -457,7 +457,7 @@ class btree<ip_address_t, value_T>
 		}
 	}
 
-	std::vector<ip_prefix_t> get_all_top() const
+	[[nodiscard]] std::vector<ip_prefix_t> get_all_top() const
 	{
 		std::vector<ip_prefix_t> result;
 
diff --git a/common/bufferring.h b/common/bufferring.h
index 6f54a2f5..a27d2b98 100644
--- a/common/bufferring.h
+++ b/common/bufferring.h
@@ -21,14 +21,11 @@ namespace common
 class bufferring
 {
 public:
-	bufferring()
-	{
-	}
+	bufferring() = default;
 	bufferring(void* memory, int unit_size, int units_number) :
 	        unit_size(unit_size),
-	        units_number(units_number)
+	        units_number(units_number), ring((ring_t*)memory)
 	{
-		ring = (ring_t*)memory;
 	}
 
 	struct ring_header_t
diff --git a/common/config.autotest.h b/common/config.autotest.h
index 7a270049..5e87c725 100644
--- a/common/config.autotest.h
+++ b/common/config.autotest.h
@@ -1,3 +1,2 @@
-#include "config.release.h"
 
 #define CONFIG_YADECAP_AUTOTEST
diff --git a/common/controlplaneconfig.h b/common/controlplaneconfig.h
index a763589f..da9a6d4d 100644
--- a/common/controlplaneconfig.h
+++ b/common/controlplaneconfig.h
@@ -4,7 +4,6 @@
 
 #include "balancer.h"
 #include "scheduler.h"
-#include "stream.h"
 #include "type.h"
 
 namespace controlplane
@@ -13,15 +12,7 @@ namespace controlplane
 class state_timeout
 {
 public:
-	state_timeout() :
-	        tcp_syn(YANET_CONFIG_STATE_TIMEOUT_DEFAULT),
-	        tcp_ack(YANET_CONFIG_STATE_TIMEOUT_DEFAULT),
-	        tcp_fin(YANET_CONFIG_STATE_TIMEOUT_DEFAULT),
-	        udp(YANET_CONFIG_STATE_TIMEOUT_DEFAULT),
-	        icmp(YANET_CONFIG_STATE_TIMEOUT_DEFAULT),
-	        other(YANET_CONFIG_STATE_TIMEOUT_DEFAULT)
-	{
-	}
+	state_timeout() = default;
 
 	operator std::tuple<uint16_t, uint16_t, uint16_t, uint16_t, uint16_t, uint16_t>() const
 	{
@@ -29,12 +20,12 @@ class state_timeout
 	}
 
 public:
-	uint16_t tcp_syn;
-	uint16_t tcp_ack;
-	uint16_t tcp_fin;
-	uint16_t udp;
-	uint16_t icmp;
-	uint16_t other;
+	uint16_t tcp_syn{YANET_CONFIG_STATE_TIMEOUT_DEFAULT};
+	uint16_t tcp_ack{YANET_CONFIG_STATE_TIMEOUT_DEFAULT};
+	uint16_t tcp_fin{YANET_CONFIG_STATE_TIMEOUT_DEFAULT};
+	uint16_t udp{YANET_CONFIG_STATE_TIMEOUT_DEFAULT};
+	uint16_t icmp{YANET_CONFIG_STATE_TIMEOUT_DEFAULT};
+	uint16_t other{YANET_CONFIG_STATE_TIMEOUT_DEFAULT};
 };
 
 [[maybe_unused]] static void from_json(const nlohmann::json& json,
@@ -90,42 +81,14 @@ namespace route
 class interface_t
 {
 public:
-	interface_t()
-	{
-	}
+	interface_t() = default;
 
 	/** @todo: tag:CP_MODULES
 	void load(const nlohmann::json& json);
 	nlohmann::json save() const;
 	*/
 
-	void pop(common::stream_in_t& stream)
-	{
-		stream.pop(interfaceId);
-		stream.pop(ip_prefixes);
-		stream.pop(neighborIPv4Address);
-		stream.pop(neighborIPv6Address);
-		stream.pop(static_neighbor_mac_address_v4);
-		stream.pop(static_neighbor_mac_address_v6);
-		stream.pop(nextModule);
-		stream.pop(acl);
-		stream.pop(aclId);
-		stream.pop(flow);
-	}
-
-	void push(common::stream_out_t& stream) const
-	{
-		stream.push(interfaceId);
-		stream.push(ip_prefixes);
-		stream.push(neighborIPv4Address);
-		stream.push(neighborIPv6Address);
-		stream.push(static_neighbor_mac_address_v4);
-		stream.push(static_neighbor_mac_address_v6);
-		stream.push(nextModule);
-		stream.push(acl);
-		stream.push(aclId);
-		stream.push(flow);
-	}
+	SERIALIZABLE(interfaceId, ip_prefixes, neighborIPv4Address, neighborIPv6Address, static_neighbor_mac_address_v4, static_neighbor_mac_address_v6, nextModule, acl, aclId, flow);
 
 public:
 	tInterfaceId interfaceId;
@@ -144,52 +107,20 @@ class interface_t
 class config_t
 {
 public:
-	config_t() :
-	        vrf("default"),
-	        tunnel_enabled(false)
-	{
-	}
+	config_t() = default;
 
 	/** @todo: tag:CP_MODULES
 	void load(const nlohmann::json& json);
 	nlohmann::json save() const;
 	*/
 
-	void pop(common::stream_in_t& stream)
-	{
-		stream.pop(routeId);
-		stream.pop(to_kernel_prefixes);
-		stream.pop(vrf);
-		stream.pop(tunnel_enabled);
-		stream.pop(ignore_tables);
-		stream.pop(ipv4_source_address);
-		stream.pop(ipv6_source_address);
-		stream.pop(udp_destination_port);
-		stream.pop(local_prefixes);
-		stream.pop(peers);
-		stream.pop(interfaces);
-	}
-
-	void push(common::stream_out_t& stream) const
-	{
-		stream.push(routeId);
-		stream.push(to_kernel_prefixes);
-		stream.push(vrf);
-		stream.push(tunnel_enabled);
-		stream.push(ignore_tables);
-		stream.push(ipv4_source_address);
-		stream.push(ipv6_source_address);
-		stream.push(udp_destination_port);
-		stream.push(local_prefixes);
-		stream.push(peers);
-		stream.push(interfaces);
-	}
+	SERIALIZABLE(routeId, to_kernel_prefixes, vrf, tunnel_enabled, ignore_tables, ipv4_source_address, ipv6_source_address, udp_destination_port, local_prefixes, peers, interfaces);
 
 public:
 	tRouteId routeId;
 	std::set<common::ip_prefix_t> to_kernel_prefixes;
-	std::string vrf;
-	bool tunnel_enabled;
+	std::string vrf{"default"};
+	bool tunnel_enabled{};
 	std::set<std::string> ignore_tables;
 	common::ipv4_address_t ipv4_source_address;
 	common::ipv6_address_t ipv6_source_address;
@@ -212,37 +143,7 @@ class config_t
 	nlohmann::json save() const;
 	*/
 
-	void pop(common::stream_in_t& stream)
-	{
-		stream.pop(dregressId);
-		stream.pop(ipv6SourcePrefixes);
-		stream.pop(ipv6DestinationPrefix);
-		stream.pop(ipv4SourceAddress);
-		stream.pop(ipv6SourceAddress);
-		stream.pop(udpDestinationPort);
-		stream.pop(onlyLongest);
-		stream.pop(communities);
-		stream.pop(localPrefixes);
-		stream.pop(announces);
-		stream.pop(ourAs);
-		stream.pop(nextModule);
-	}
-
-	void push(common::stream_out_t& stream) const
-	{
-		stream.push(dregressId);
-		stream.push(ipv6SourcePrefixes);
-		stream.push(ipv6DestinationPrefix);
-		stream.push(ipv4SourceAddress);
-		stream.push(ipv6SourceAddress);
-		stream.push(udpDestinationPort);
-		stream.push(onlyLongest);
-		stream.push(communities);
-		stream.push(localPrefixes);
-		stream.push(announces);
-		stream.push(ourAs);
-		stream.push(nextModule);
-	}
+	SERIALIZABLE(dregressId, ipv6SourcePrefixes, ipv6DestinationPrefix, ipv4SourceAddress, ipv6SourceAddress, udpDestinationPort, onlyLongest, communities, localPrefixes, announces, ourAs, nextModule);
 
 public:
 	dregress_id_t dregressId;
@@ -264,8 +165,7 @@ class config_t
 namespace balancer
 {
 
-YANET_UNUSED
-static uint8_t to_proto(const std::string& string)
+[[maybe_unused]] static uint8_t to_proto(const std::string& string)
 {
 	if (string == "tcp")
 	{
@@ -279,8 +179,7 @@ static uint8_t to_proto(const std::string& string)
 	return 0;
 }
 
-YANET_UNUSED
-constexpr const char* from_proto(const uint8_t& proto)
+[[maybe_unused]] constexpr const char* from_proto(const uint8_t& proto)
 {
 	switch (proto)
 	{
@@ -317,37 +216,14 @@ using service_t = std::tuple<balancer_service_id_t,
 class config_t
 {
 public:
-	config_t() :
-	        reals_count(0)
-	{
-	}
+	config_t() = default;
 
 	/** @todo: tag:CP_MODULES
 	void load(const nlohmann::json& json);
 	nlohmann::json save() const;
 	*/
 
-	void pop(common::stream_in_t& stream)
-	{
-		stream.pop(balancer_id);
-		stream.pop(services);
-		stream.pop(source_ipv6);
-		stream.pop(source_ipv4);
-		stream.pop(vip_to_balancers);
-		stream.pop(default_wlc_power);
-		stream.pop(next_module);
-	}
-
-	void push(common::stream_out_t& stream) const
-	{
-		stream.push(balancer_id);
-		stream.push(services);
-		stream.push(source_ipv6);
-		stream.push(source_ipv4);
-		stream.push(vip_to_balancers);
-		stream.push(default_wlc_power);
-		stream.push(next_module);
-	}
+	SERIALIZABLE(balancer_id, services, source_ipv6, source_ipv4, vip_to_balancers, default_wlc_power, next_module);
 
 public:
 	balancer_id_t balancer_id;
@@ -364,7 +240,7 @@ class config_t
 	std::string next_module;
 	common::globalBase::tFlow flow;
 
-	uint64_t reals_count;
+	uint64_t reals_count{};
 };
 
 }
@@ -375,50 +251,23 @@ namespace tun64
 class config_t
 {
 public:
-	config_t() :
-	        dscpMarkType(common::eDscpMarkType::never),
-	        dscp(0),
-	        srcRndEnabled(false)
-	{
-	}
+	config_t() = default;
 
 	/** @todo: tag:CP_MODULES
        void load(const nlohmann::json& json);
        nlohmann::json save() const;
        */
 
-	void pop(common::stream_in_t& stream)
-	{
-		stream.pop(tun64Id);
-		stream.pop(dscpMarkType);
-		stream.pop(dscp);
-		stream.pop(ipv6SourceAddress);
-		stream.pop(srcRndEnabled);
-		stream.pop(prefixes);
-		stream.pop(mappings);
-		stream.pop(nextModule);
-	}
-
-	void push(common::stream_out_t& stream) const
-	{
-		stream.push(tun64Id);
-		stream.push(dscpMarkType);
-		stream.push(dscp);
-		stream.push(ipv6SourceAddress);
-		stream.push(srcRndEnabled);
-		stream.push(prefixes);
-		stream.push(mappings);
-		stream.push(nextModule);
-	}
+	SERIALIZABLE(tun64Id, dscpMarkType, dscp, ipv6SourceAddress, srcRndEnabled, prefixes, mappings, nextModule);
 
 public:
 	tun64_id_t tun64Id;
 
-	common::eDscpMarkType dscpMarkType;
-	uint8_t dscp;
+	common::eDscpMarkType dscpMarkType{common::eDscpMarkType::never};
+	uint8_t dscp{};
 
 	common::ipv6_address_t ipv6SourceAddress;
-	bool srcRndEnabled; /// < IPv6 Source address randomization
+	bool srcRndEnabled{}; /// < IPv6 Source address randomization
 
 	std::set<common::ip_prefix_t> prefixes;
 	std::map<common::ipv4_address_t,
@@ -438,38 +287,14 @@ namespace nat64stateful
 class config_t
 {
 public:
-	config_t() :
-	        dscp_mark_type(common::eDscpMarkType::never),
-	        dscp(0)
-	{
-	}
+	config_t() = default;
 
-	void pop(common::stream_in_t& stream)
-	{
-		stream.pop(nat64stateful_id);
-		stream.pop(dscp_mark_type);
-		stream.pop(dscp);
-		stream.pop(ipv6_prefixes);
-		stream.pop(ipv4_prefixes);
-		stream.pop(announces);
-		stream.pop(next_module);
-	}
-
-	void push(common::stream_out_t& stream) const
-	{
-		stream.push(nat64stateful_id);
-		stream.push(dscp_mark_type);
-		stream.push(dscp);
-		stream.push(ipv6_prefixes);
-		stream.push(ipv4_prefixes);
-		stream.push(announces);
-		stream.push(next_module);
-	}
+	SERIALIZABLE(nat64stateful_id, dscp_mark_type, dscp, ipv6_prefixes, ipv4_prefixes, announces, next_module);
 
 public:
 	nat64stateful_id_t nat64stateful_id;
-	common::eDscpMarkType dscp_mark_type;
-	uint8_t dscp;
+	common::eDscpMarkType dscp_mark_type{common::eDscpMarkType::never};
+	uint8_t dscp{};
 	std::vector<common::ipv6_prefix_t> ipv6_prefixes;
 	std::vector<common::ipv4_prefix_t> ipv4_prefixes;
 	std::set<common::ip_prefix_t> announces;
diff --git a/common/ctree.h b/common/ctree.h
index c12259af..61899b4e 100644
--- a/common/ctree.h
+++ b/common/ctree.h
@@ -25,8 +25,7 @@ struct ctree
 			root_node = new node_base_t();
 		}
 	}
-	ctree(ctree&& other) :
-	        root_node{}
+	ctree(ctree&& other)
 	{
 		if (this != &other)
 		{
@@ -147,8 +146,8 @@ struct ctree
 		                   const std::vector<std::string>& key_names,
 		                   const std::function<void(const std::string& key, const values_t&)>& callback) const
 		{
-			(void)key_index;
-			(void)key_names;
+			YANET_GCC_BUG_UNUSED(key_index);
+			YANET_GCC_BUG_UNUSED(key_names);
 
 			callback(key, values);
 		}
@@ -196,7 +195,7 @@ struct ctree
 		{
 			for (auto& [next_counter, next_node] : next)
 			{
-				(void)next_counter;
+				YANET_GCC_BUG_UNUSED(next_counter);
 				delete next_node;
 			}
 		}
@@ -272,7 +271,7 @@ struct ctree
 			{
 				for (const auto& [next_counter, next_node] : next)
 				{
-					(void)next_counter;
+					YANET_GCC_BUG_UNUSED(next_counter);
 					static_cast<node_t<next_counters_T...>*>(next_node)->convert_update(next_converts...);
 				}
 			}
@@ -392,7 +391,7 @@ struct ctree
 		        convert;
 	};
 
-	node_base_t* root_node;
+	node_base_t* root_node{};
 };
 
 } // namespace common
diff --git a/common/define.h b/common/define.h
index 2f4986f2..47cc5fd0 100644
--- a/common/define.h
+++ b/common/define.h
@@ -1,17 +1,30 @@
 #pragma once
 
+#include <cstdint>
 #include <cstdio>
 #include <cstdlib>
 #include <ctime>
 #include <map>
 #include <optional>
 #include <set>
-#include <string_view>
 #include <vector>
 
-#include <inttypes.h>
-
-#define YANET_UNUSED [[maybe_unused]]
+/**
+ *  GCC 7.5 version which we have to support for now due to Ubuntu 18 have a bug
+ *  (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=81767) where unused variables
+ *  in structured bindings are incorrectly flagged as warnings, even though
+ *  they "can't" be used, cause they are not a real variables.
+ *
+ *  Previously, code used `(void)var;` to suppress these warnings, but this
+ *  approach was ugly and harder to grep.
+ *
+ *  One should use this macro in structured bindings to mark unused bunding.
+ *
+ *  Once we move to a newer GCC version where this bug is fixed,
+ *  we can easily remove this macro as it is much easier to grep and remove
+ *  than those void(var) statements.
+ */
+#define YANET_GCC_BUG_UNUSED(arg) (void)(arg)
 
 #define YANET_LOG_PRINT(msg, args...) fprintf(stdout, msg, ##args)
 
@@ -112,6 +125,31 @@ extern LogPriority logPriority;
 
 #define YANET_NEXTHOP_FLAG_DIRECTLY ((uint16_t)(1u << 0))
 
+/*
+ * @brief Macro to define serialization-friendly tuple accessors.
+ *
+ * Example usage:
+ * \code
+ * class MyClass {
+ * public:
+ *     int a;
+ *     std::string b;
+ *
+ *     // Automatically defines as_tuple() methods
+ *     SERIALIZABLE(a, b);
+ * };
+ * \endcode
+ *
+ * In cases where serialization/deserialization logic for a class is not
+ * straightforward or requires custom handling, you should define explicit
+ * `pop` and `push` methods as before, instead of using this macro.
+ *
+ * @param __VA_ARGS__ List of member variables to include in the tuple.
+ */
+#define SERIALIZABLE(...)                                 \
+	auto as_tuple() { return std::tie(__VA_ARGS__); } \
+	auto as_tuple() const { return std::tie(__VA_ARGS__); }
+
 /// @todo: move
 template<typename map_T,
          typename key_T>
diff --git a/common/generation.h b/common/generation.h
index 26ab14e6..fd93a097 100644
--- a/common/generation.h
+++ b/common/generation.h
@@ -123,7 +123,7 @@ class generation_manager
 	/** dangerous
 	generation_shared current_shared() const
 	{
-		return generation_shared(&current_mutex, this);
+	        return generation_shared(&current_mutex, this);
 	}
 	*/
 
@@ -145,7 +145,7 @@ class generation_manager
 	/** dangerous
 	generation_unique next_unique()
 	{
-		return generation_unique(&next_mutex, this);
+	        return generation_unique(&next_mutex, this);
 	}
 	*/
 
diff --git a/common/icontrolplane.h b/common/icontrolplane.h
index c16a182a..88f25283 100644
--- a/common/icontrolplane.h
+++ b/common/icontrolplane.h
@@ -13,10 +13,7 @@ namespace interface
 class controlPlane
 {
 public:
-	controlPlane() :
-	        clientSocket(-1)
-	{
-	}
+	controlPlane() = default;
 
 	~controlPlane()
 	{
@@ -387,7 +384,7 @@ class controlPlane
 	}
 
 	template<common::icp::requestType T, class Req = std::tuple<>>
-	inline common::icp::response call(const Req& request = Req()) const
+	common::icp::response call(const Req& request = Req()) const
 	{
 		std::lock_guard<std::mutex> guard(mutex);
 		connectToControlPlane();
@@ -395,7 +392,7 @@ class controlPlane
 	}
 
 protected:
-	mutable int clientSocket;
+	mutable int clientSocket{-1};
 	mutable std::mutex mutex;
 };
 
diff --git a/common/icp.h b/common/icp.h
index 8f377312..d5103a29 100644
--- a/common/icp.h
+++ b/common/icp.h
@@ -15,9 +15,7 @@
 #include "result.h"
 #include "type.h"
 
-namespace common
-{
-namespace icp
+namespace common::icp
 {
 
 constexpr inline char socketPath[] = "/run/yanet/controlplane.sock";
@@ -1021,4 +1019,3 @@ using response = std::variant<std::tuple<>,
                               convert::response,
                               counters_stat::response>;
 }
-}
diff --git a/common/icp_proto.h b/common/icp_proto.h
index 0b68dd70..25bd18d2 100644
--- a/common/icp_proto.h
+++ b/common/icp_proto.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "libprotobuf/controlplane.pb.h"
-
 namespace common::icp_proto
 {
 constexpr inline char socketPath[] = "/run/yanet/protocontrolplane.sock";
diff --git a/common/idataplane.h b/common/idataplane.h
index eb131d56..8ede607d 100644
--- a/common/idataplane.h
+++ b/common/idataplane.h
@@ -14,10 +14,7 @@ namespace interface
 class dataPlane
 {
 public:
-	dataPlane() :
-	        clientSocket(-1)
-	{
-	}
+	dataPlane() = default;
 
 	~dataPlane()
 	{
@@ -283,7 +280,7 @@ class dataPlane
 	}
 
 	template<common::idp::requestType T, class Req>
-	inline common::idp::response call(const Req& request) const
+	common::idp::response call(const Req& request) const
 	{
 		std::lock_guard<std::mutex> guard(mutex);
 		connectToDataPlane();
@@ -297,7 +294,7 @@ class dataPlane
 	}
 
 	template<common::idp::requestType T, class Req>
-	inline common::idp::response call(Req&& request) const
+	common::idp::response call(Req&& request) const
 	{
 		std::lock_guard<std::mutex> guard(mutex);
 		connectToDataPlane();
@@ -305,7 +302,7 @@ class dataPlane
 	}
 
 protected:
-	mutable int clientSocket;
+	mutable int clientSocket{-1};
 	mutable std::mutex mutex;
 };
 
diff --git a/common/idp.h b/common/idp.h
index aac44526..8719cd0d 100644
--- a/common/idp.h
+++ b/common/idp.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <inttypes.h>
-
 #include <array>
 #include <map>
 #include <set>
diff --git a/common/memory_manager.h b/common/memory_manager.h
index 04e994a8..bd07ab04 100644
--- a/common/memory_manager.h
+++ b/common/memory_manager.h
@@ -1,9 +1,10 @@
 #pragma once
 
 #include <memory>
+#include <string>
 #include <vector>
 
-#include "stream.h"
+#include "common/define.h"
 
 namespace common::memory_manager
 {
@@ -38,10 +39,7 @@ inline uint64_t convert_string_to_bytes(std::string string)
 class memory_group
 {
 public:
-	memory_group() :
-	        limit(0)
-	{
-	}
+	memory_group() = default;
 
 	template<typename callback_t>
 	std::set<std::string> for_each(const callback_t& callback) const
@@ -68,23 +66,11 @@ class memory_group
 		return object_names;
 	}
 
-	void pop(common::stream_in_t& stream)
-	{
-		stream.pop(name);
-		stream.pop(limit);
-		stream.pop(memory_groups);
-	}
-
-	void push(common::stream_out_t& stream) const
-	{
-		stream.push(name);
-		stream.push(limit);
-		stream.push(memory_groups);
-	}
+	SERIALIZABLE(name, limit, memory_groups);
 
 public:
 	std::string name;
-	uint64_t limit;
+	uint64_t limit{};
 	std::vector<std::shared_ptr<memory_group>> memory_groups;
 };
 
diff --git a/common/nat46clat.h b/common/nat46clat.h
index b3c587d8..031aeaa5 100644
--- a/common/nat46clat.h
+++ b/common/nat46clat.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "stream.h"
 #include "type.h"
 
 namespace nat46clat
@@ -18,49 +17,20 @@ enum class module_counter : tCounterId
 class config
 {
 public:
-	config() :
-	        dscp_mark_type(common::eDscpMarkType::never),
-	        dscp(0)
-	{
-	}
+	config() = default;
 
-	void pop(common::stream_in_t& stream)
-	{
-		stream.pop(nat46clat_id);
-		stream.pop(ipv6_source);
-		stream.pop(ipv6_destination);
-		stream.pop(dscp_mark_type);
-		stream.pop(dscp);
-		stream.pop(ipv6_prefixes);
-		stream.pop(ipv4_prefixes);
-		stream.pop(announces);
-		stream.pop(next_module);
-	}
-
-	void push(common::stream_out_t& stream) const
-	{
-		stream.push(nat46clat_id);
-		stream.push(ipv6_source);
-		stream.push(ipv6_destination);
-		stream.push(dscp_mark_type);
-		stream.push(dscp);
-		stream.push(ipv6_prefixes);
-		stream.push(ipv4_prefixes);
-		stream.push(announces);
-		stream.push(next_module);
-	}
+	SERIALIZABLE(nat46clat_id, ipv6_source, ipv6_destination, dscp_mark_type, dscp, ipv6_prefixes, ipv4_prefixes, announces, next_module);
 
 public:
 	nat46clat_id_t nat46clat_id;
 	common::ipv6_address_t ipv6_source;
 	common::ipv6_address_t ipv6_destination;
-	common::eDscpMarkType dscp_mark_type;
-	uint8_t dscp;
+	common::eDscpMarkType dscp_mark_type{common::eDscpMarkType::never};
+	uint8_t dscp{};
 	std::set<common::ipv6_prefix_t> ipv6_prefixes;
 	std::set<common::ipv4_prefix_t> ipv4_prefixes;
 	std::set<common::ip_prefix_t> announces;
 	std::string next_module;
 	common::globalBase::flow_t flow;
 };
-
 }
diff --git a/common/neighbor.h b/common/neighbor.h
index 01032091..7037ae5f 100644
--- a/common/neighbor.h
+++ b/common/neighbor.h
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <inttypes.h>
-
+#include <cstdint>
 namespace common::neighbor
 {
 
diff --git a/common/refarray.h b/common/refarray.h
index a2c770a6..ea779bb4 100644
--- a/common/refarray.h
+++ b/common/refarray.h
@@ -17,10 +17,9 @@ class refarray_t
 	using id_t = uint64_t;
 
 public:
-	refarray_t() ///< @todo: fallback value?
+	refarray_t() :
+	        ids_unused_size(size_T) ///< @todo: fallback value?
 	{
-		ids_unused_size = size_T;
-		ids_unused_watermark = 0;
 	}
 
 	bool exist_id(const id_t& id)
@@ -42,7 +41,7 @@ class refarray_t
 		}
 
 		auto& [refcount, id] = it->second;
-		(void)id;
+		YANET_GCC_BUG_UNUSED(id);
 
 		refcount++;
 
@@ -59,7 +58,7 @@ class refarray_t
 			return std::nullopt;
 		}
 
-		id_t id;
+		id_t id = 0;
 		ids_unused_size--;
 		if (ids_unused.size())
 		{
@@ -107,7 +106,7 @@ class refarray_t
 
 		const auto& value = it->second;
 		auto& [refcount, values_id] = values[value];
-		(void)values_id;
+		YANET_GCC_BUG_UNUSED(values_id);
 
 		refcount--;
 		if (refcount)
@@ -163,7 +162,7 @@ class refarray_t
 
 		auto it = values.find(value);
 		const auto& [refcount, id] = it->second;
-		(void)refcount;
+		YANET_GCC_BUG_UNUSED(refcount);
 
 		return id;
 	}
@@ -186,7 +185,7 @@ class refarray_t
 		ids.clear();
 	}
 
-	std::tuple<uint64_t, uint64_t> stats() const
+	[[nodiscard]] std::tuple<uint64_t, uint64_t> stats() const
 	{
 		return {size_T - ids_unused_size, size_T};
 	}
@@ -203,7 +202,7 @@ class refarray_t
 
 protected:
 	std::vector<id_t> ids_unused;
-	std::atomic<id_t> ids_unused_watermark;
+	std::atomic<id_t> ids_unused_watermark{0};
 
 	std::map<value_T,
 	         std::tuple<uint64_t, ///< refcount
diff --git a/common/result.h b/common/result.h
index d4d5b1cc..e60719bc 100644
--- a/common/result.h
+++ b/common/result.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include <inttypes.h>
+#include <cstdint>
 
 namespace common
 {
diff --git a/common/rpc_channel.h b/common/rpc_channel.h
index fc406d02..12949b38 100644
--- a/common/rpc_channel.h
+++ b/common/rpc_channel.h
@@ -16,14 +16,12 @@ namespace common::proto
 class UnixProtobufRpcChannel : public google::protobuf::RpcChannel
 {
 public:
-	UnixProtobufRpcChannel(const std::string& socketPath) :
-	        clientSocket(-1)
+	UnixProtobufRpcChannel(const std::string& socketPath)
 	{
-
 		connectChannel(socketPath);
 	}
 
-	~UnixProtobufRpcChannel()
+	~UnixProtobufRpcChannel() override
 	{
 		if (clientSocket != -1)
 		{
@@ -60,11 +58,11 @@ class UnixProtobufRpcChannel : public google::protobuf::RpcChannel
 		}
 	}
 
-	virtual void CallMethod(const ::google::protobuf::MethodDescriptor* method,
-	                        ::google::protobuf::RpcController* controller,
-	                        const ::google::protobuf::Message* request,
-	                        ::google::protobuf::Message* response,
-	                        ::google::protobuf::Closure*)
+	void CallMethod(const ::google::protobuf::MethodDescriptor* method,
+	                ::google::protobuf::RpcController* controller,
+	                const ::google::protobuf::Message* request,
+	                ::google::protobuf::Message* response,
+	                ::google::protobuf::Closure*) override
 	{
 		std::lock_guard<std::mutex> guard(mutex);
 		// Get the service name method name and fill it into rpc_meta
@@ -86,7 +84,7 @@ class UnixProtobufRpcChannel : public google::protobuf::RpcChannel
 
 		// single response
 
-		uint64_t messageSize;
+		uint64_t messageSize = 0;
 		if (auto err = common::recvAll(clientSocket, (char*)&messageSize, sizeof(messageSize)); err != 0)
 		{
 			controller->SetFailed(std::string("recv response: ") + strerror(err));
@@ -103,7 +101,7 @@ class UnixProtobufRpcChannel : public google::protobuf::RpcChannel
 	}
 
 private:
-	mutable int clientSocket;
+	mutable int clientSocket{-1};
 	mutable std::mutex mutex{};
 	std::vector<uint8_t> buffer;
 };
diff --git a/common/rpc_controller.h b/common/rpc_controller.h
index f538877a..b11d247f 100644
--- a/common/rpc_controller.h
+++ b/common/rpc_controller.h
@@ -11,23 +11,23 @@ class RpcController : public google::protobuf::RpcController
 {
 public:
 	RpcController() { _reset(); }
-	virtual ~RpcController() {}
+	~RpcController() override = default;
 
-	virtual void Reset()
+	void Reset() override
 	{
 		_reset();
 	}
 
-	virtual bool Failed() const { return is_failed_; }
-	virtual void SetFailed(const std::string& reason)
+	[[nodiscard]] bool Failed() const override { return is_failed_; }
+	void SetFailed(const std::string& reason) override
 	{
 		is_failed_ = true;
 		error_code_ = reason;
 	}
-	virtual std::string ErrorText() const { return error_code_; }
-	virtual void StartCancel(){};
-	virtual bool IsCanceled() const { return false; };
-	virtual void NotifyOnCancel(::google::protobuf::Closure* /* callback */){};
+	[[nodiscard]] std::string ErrorText() const override { return error_code_; }
+	void StartCancel() override {};
+	[[nodiscard]] bool IsCanceled() const override { return false; };
+	void NotifyOnCancel(::google::protobuf::Closure* /* callback */) override {};
 
 private:
 	bool is_failed_;
diff --git a/common/scheduler.h b/common/scheduler.h
index 6ef48956..6fe773ac 100644
--- a/common/scheduler.h
+++ b/common/scheduler.h
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <inttypes.h>
-
+#include <cstdint>
 namespace balancer
 {
 
diff --git a/common/sdpclient.h b/common/sdpclient.h
index b2b91007..990cb31a 100644
--- a/common/sdpclient.h
+++ b/common/sdpclient.h
@@ -33,7 +33,7 @@ class SdpClient
 		{
 			number_of_attempts++;
 			std::string message_error;
-			uint64_t size_mmap;
+			uint64_t size_mmap = 0;
 			result = ReadItAgainMainFileDataplane(sdp_data, size_mmap, message_error);
 			if (result == eResultRead::error)
 			{
@@ -177,8 +177,8 @@ class SdpClient
 			{
 				if (!core_id.has_value() || worker_core_id == core_id)
 				{
-					uint64_t* counters = common::sdp::ShiftBuffer<uint64_t*>(worker_info.buffer,
-					                                                         sdp_data.metadata_worker.start_counters);
+					auto* counters = common::sdp::ShiftBuffer<uint64_t*>(worker_info.buffer,
+					                                                     sdp_data.metadata_worker.start_counters);
 					result[worker_core_id] = counters[index];
 				}
 			}
@@ -193,8 +193,8 @@ class SdpClient
 			{
 				if (!core_id.has_value() || worker_core_id == core_id)
 				{
-					uint64_t* counters = common::sdp::ShiftBuffer<uint64_t*>(worker_info.buffer,
-					                                                         sdp_data.metadata_worker.start_counters);
+					auto* counters = common::sdp::ShiftBuffer<uint64_t*>(worker_info.buffer,
+					                                                     sdp_data.metadata_worker.start_counters);
 					result[worker_core_id] = counters[index];
 				}
 			}
@@ -429,7 +429,7 @@ class SdpClient
 
 	static uint64_t ReadValue(void* buffer, uint64_t index)
 	{
-		uint8_t* data = common::sdp::ShiftBuffer<uint8_t*>(buffer, index * sizeof(uint64_t));
+		auto* data = common::sdp::ShiftBuffer<uint8_t*>(buffer, index * sizeof(uint64_t));
 		uint64_t result = 0;
 		for (int i = 0; i < 8; i++)
 		{
diff --git a/common/sdpcommon.h b/common/sdpcommon.h
index d3d7900c..0fda626d 100644
--- a/common/sdpcommon.h
+++ b/common/sdpcommon.h
@@ -6,9 +6,6 @@
 
 #include "define.h"
 #include "idp.h"
-#include "shared_memory.h"
-#include "stream.h"
-#include "type.h"
 
 // #define YANET_USE_POSIX_SHARED_MEMORY
 
@@ -223,13 +220,13 @@ struct DataPlaneInSharedMemory
 		return ((value + 63) / 64) * 64;
 	}
 
-	std::tuple<uint64_t*, uint64_t*, uint64_t*> BuffersBus() const
+	[[nodiscard]] std::tuple<uint64_t*, uint64_t*, uint64_t*> BuffersBus() const
 	{
-		uint32_t count_errors = static_cast<uint32_t>(common::idp::errorType::size);
-		uint32_t count_requests = static_cast<uint32_t>(common::idp::requestType::size);
-		uint64_t* requests = common::sdp::ShiftBuffer<uint64_t*>(dataplane_data, start_bus_section);
-		uint64_t* errors = common::sdp::ShiftBuffer<uint64_t*>(dataplane_data, start_bus_section + count_requests * sizeof(uint64_t));
-		uint64_t* durations = common::sdp::ShiftBuffer<uint64_t*>(dataplane_data, start_bus_section + (count_requests + count_errors) * sizeof(uint64_t));
+		auto count_errors = static_cast<uint32_t>(common::idp::errorType::size);
+		auto count_requests = static_cast<uint32_t>(common::idp::requestType::size);
+		auto* requests = common::sdp::ShiftBuffer<uint64_t*>(dataplane_data, start_bus_section);
+		auto* errors = common::sdp::ShiftBuffer<uint64_t*>(dataplane_data, start_bus_section + count_requests * sizeof(uint64_t));
+		auto* durations = common::sdp::ShiftBuffer<uint64_t*>(dataplane_data, start_bus_section + (count_requests + count_errors) * sizeof(uint64_t));
 		return {requests, errors, durations};
 	}
 };
diff --git a/common/sendrecv.h b/common/sendrecv.h
index 328338f6..d2435214 100644
--- a/common/sendrecv.h
+++ b/common/sendrecv.h
@@ -2,8 +2,8 @@
 
 #include <string>
 
+#include <cstring>
 #include <google/protobuf/message.h>
-#include <string.h>
 #include <sys/socket.h>
 #include <unistd.h>
 #include <vector>
@@ -118,11 +118,11 @@ static int send(int clientSocket, Req&& request)
 }
 
 template<class Resp>
-static inline Resp recv(int clientSocket) //unsafe
+static inline Resp recv(int clientSocket) // unsafe
 {
 	std::vector<uint8_t> buffer;
 
-	uint64_t messageSize;
+	uint64_t messageSize = 0;
 	if (auto err = recvAll(clientSocket, (char*)&messageSize, sizeof(messageSize)); err != 0)
 	{
 		throw std::string("recv(): ") + strerror(err);
diff --git a/common/shared_memory.h b/common/shared_memory.h
index 0d118e1c..e601c8be 100644
--- a/common/shared_memory.h
+++ b/common/shared_memory.h
@@ -1,10 +1,10 @@
 #pragma once
 
+#include <cstring>
 #include <fcntl.h>
 #include <numa.h>
 #include <numaif.h>
 #include <optional>
-#include <string.h>
 #include <sys/mman.h>
 #include <sys/shm.h>
 #include <sys/stat.h>
@@ -33,7 +33,7 @@ class SharedMemory
 		const char* str_hugetlb = "Hugetlb:";
 
 		FILE* fd = fopen(path_meminfo, "r");
-		if (fd == NULL)
+		if (fd == nullptr)
 		{
 			YANET_LOG_ERROR("Cannot open %s, error %d: %s\n", path_meminfo, errno, strerror(errno));
 			return false;
@@ -52,7 +52,7 @@ class SharedMemory
 				{
 					str++;
 				}
-				char* endptr;
+				char* endptr = nullptr;
 				unsigned long long size = strtoull(str, &endptr, 0);
 				// The string still contains kB (or mB, gB), but it only matters to us
 				// whether the value is 0 or not
@@ -282,11 +282,11 @@ class SharedMemory
 	static std::pair<struct bitmask*, int> SetMemoryPolicy(std::optional<tSocketId> socket_id)
 	{
 		struct bitmask* oldmask = nullptr;
-		int oldpolicy;
+		int oldpolicy = 0;
 		if (socket_id.has_value())
 		{
 			oldmask = numa_allocate_nodemask();
-			if (get_mempolicy(&oldpolicy, oldmask->maskp, oldmask->size + 1, 0, 0) < 0)
+			if (get_mempolicy(&oldpolicy, oldmask->maskp, oldmask->size + 1, nullptr, 0) < 0)
 			{
 				YANET_LOG_WARNING("get_mempolicy(): %s, continue with the use of sockets turned off\n", strerror(errno));
 				oldpolicy = MPOL_DEFAULT;
diff --git a/common/static_vector.h b/common/static_vector.h
index b4642847..1e954a8b 100644
--- a/common/static_vector.h
+++ b/common/static_vector.h
@@ -1,62 +1,34 @@
 #pragma once
-#include <algorithm>
 
+#include <algorithm>
+#include <array>
 #include <stdexcept>
+#include <type_traits>
+#include <utility>
 
 namespace utils
 {
 
-#ifdef STATIC_VECTOR_USE_EXCEPTIONS
-static constexpr bool USE_EXCEPTIONS = true;
-#else
-static constexpr bool USE_EXCEPTIONS = false;
-#endif
-
-template<typename T, std::size_t Cap>
+template<typename T, std::size_t Cap, bool UseExceptions = false>
 class StaticVector
 {
-	alignas(T) unsigned char buf_[sizeof(T[Cap])];
+	using storage_t = std::aligned_storage_t<sizeof(T), alignof(T)>;
+	std::array<storage_t, Cap> buf_;
 	std::size_t len_ = 0;
 
 	T* AddressOfIndex(std::size_t idx)
 	{
-		return reinterpret_cast<T*>(buf_) + idx;
+		return std::launder(reinterpret_cast<T*>(&buf_[idx]));
 	}
 
 	const T* AddressOfIndex(std::size_t idx) const
 	{
-		return reinterpret_cast<const T*>(buf_) + idx;
-	}
-
-	void TrivialCopy(const StaticVector& other)
-	{
-		std::copy(std::begin(other.buf_),
-		          std::begin(other.buf_) + other.len_ * sizeof(T),
-		          std::begin(buf_));
-		len_ = other.len_;
-	}
-
-	void PerElementCopy(const StaticVector& other)
-	{
-		clear();
-		for (const auto& elem : other)
-		{
-			PushBackUnsafe(elem);
-		}
-	}
-
-	void PerElementCopy(StaticVector&& other)
-	{
-		clear();
-		for (auto& elem : other)
-		{
-			PushBackUnsafe(std::move(elem));
-		}
+		return std::launder(reinterpret_cast<const T*>(&buf_[idx]));
 	}
 
 	void HandleOutOfRange()
 	{
-		if constexpr (USE_EXCEPTIONS)
+		if constexpr (UseExceptions)
 		{
 			throw std::out_of_range("");
 		}
@@ -66,94 +38,98 @@ class StaticVector
 		}
 	}
 
-	void PushBackUnsafe(const T& elem)
+	template<typename... Args>
+	void PushBackUnsafe(Args&&... args)
 	{
-		new (AddressOfIndex(len_)) T(elem);
+		new (AddressOfIndex(len_)) T(std::forward<Args>(args)...);
 		++len_;
 	}
 
-	void PushBackUnsafe(T&& elem)
+	template<typename OtherVector>
+	void PerElementTransfer(OtherVector&& other)
 	{
-		new (AddressOfIndex(len_)) T(std::move(elem));
-		++len_;
+		// If T is trivially copyable, use trivial copy
+		if constexpr (std::is_trivially_copyable_v<T>)
+		{
+			std::copy(std::begin(other.buf_), std::begin(other.buf_) + other.len_, std::begin(buf_));
+			len_ = other.len_;
+		}
+		else
+		{
+			clear();
+
+			for (auto&& elem : other)
+			{
+				PushBackUnsafe(std::forward<decltype(elem)>(elem));
+			}
+
+			// If other is an rvalue, clear the original vector
+			if constexpr (std::is_rvalue_reference_v<decltype(other)>)
+			{
+				other.clear();
+			}
+		}
 	}
 
 public:
 	using iterator = T*;
 	using const_iterator = const T*;
+
 	StaticVector() = default;
 
-	StaticVector(StaticVector&& other)
+	~StaticVector()
 	{
-		*this = std::move(other);
+		clear();
 	}
 
-	StaticVector& operator=(StaticVector&& other)
+	StaticVector(const StaticVector& other)
 	{
-		if (this == &other)
-		{
-			return *this;
-		}
-
-		if constexpr (std::is_trivially_copyable_v<T>)
-		{
-			TrivialCopy(other);
-		}
-		else
-		{
-			PerElementMove(other);
-		}
-		return *this;
+		PerElementTransfer(other);
 	}
 
-	StaticVector(const StaticVector& other)
+	StaticVector(StaticVector&& other) noexcept
 	{
-		*this = other;
+		PerElementTransfer(std::move(other));
 	}
 
 	StaticVector& operator=(const StaticVector& other)
 	{
-		if (this == &other)
-		{
-			return *this;
-		}
-		clear();
-		if constexpr (std::is_trivially_copyable_v<T>)
+		if (this != &other)
 		{
-			TrivialCopy(other);
-		}
-		else
-		{
-			PerElementCopy(other);
+			clear();
+			PerElementTransfer(other);
 		}
 		return *this;
 	}
 
-	void push_back(const T& elem)
+	StaticVector& operator=(StaticVector&& other) noexcept
 	{
-		if (Full())
+		if (this != &other)
 		{
-			HandleOutOfRange();
-			return;
+			clear();
+			PerElementTransfer(std::move(other));
 		}
-		PushBackUnsafe(elem);
+		return *this;
 	}
 
-	void push_back(T&& elem)
+	template<typename U>
+	void push_back(U&& elem)
 	{
 		if (Full())
 		{
 			HandleOutOfRange();
-			return;
 		}
-		PushBackUnsafe(std::move(elem));
+		PushBackUnsafe(std::forward<U>(elem));
 	}
 
 	template<typename... Args>
 	void emplace_back(Args&&... args)
 	{
-		new (AddressOfIndex(len_)) T(std::forward<Args>(args)...);
-		++len_;
+		if (Full())
+		{
+			HandleOutOfRange();
+		}
+		PushBackUnsafe(std::forward<Args>(args)...);
 	}
 
 	void pop_back()
@@ -161,7 +137,6 @@ class StaticVector
 		if (empty())
 		{
 			HandleOutOfRange();
-			return;
 		}
 		at(--len_).~T();
 	}
@@ -169,7 +144,6 @@ class StaticVector
 	T& operator[](std::size_t pos)
 	{
 		return *AddressOfIndex(pos);
-		// return reinterpret_cast<T&>(buf_[pos * sizeof(T)]);
 	}
 
 	const T& operator[](std::size_t pos) const
@@ -182,10 +156,8 @@ class StaticVector
 		if (pos >= size())
 		{
 			HandleOutOfRange();
-			abort();
 		}
 		return *AddressOfIndex(pos);
-		// return reinterpret_cast<T&>(buf_[pos * sizeof(T)]);
 	}
 
 	const T& at(std::size_t pos) const
@@ -193,7 +165,6 @@ class StaticVector
 		if (pos >= size())
 		{
 			HandleOutOfRange();
-			abort();
 		}
 		return *AddressOfIndex(pos);
 	}
@@ -205,13 +176,12 @@ class StaticVector
 	const_iterator cbegin() const { return AddressOfIndex(0); }
 	const_iterator cend() const { return AddressOfIndex(size()); }
 
-	[[nodiscard]] bool empty() const
-	{
-		return size() == 0;
-	}
-
-	constexpr std::size_t capacity() const { return Cap; }
+	[[nodiscard]] bool empty() const { return size() == 0; }
+	[[nodiscard]] constexpr std::size_t capacity() const { return Cap; }
+	[[nodiscard]] std::size_t size() const { return len_; }
+	[[nodiscard]] bool Full() const { return size() == capacity(); }
 
+	// Clear the vector and destruct elements
 	void clear()
 	{
 		if constexpr (std::is_trivially_destructible_v<T>)
@@ -226,9 +196,6 @@ class StaticVector
 			}
 		}
 	}
-
-	std::size_t size() const { return len_; }
-	bool Full() const { return size() == capacity(); }
 };
 
 } // namespace utils
diff --git a/common/stream.h b/common/stream.h
index 961ec9c0..3bbf6510 100644
--- a/common/stream.h
+++ b/common/stream.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <inttypes.h>
-
 #include <map>
 #include <memory>
 #include <optional>
@@ -13,6 +11,8 @@
 #include <variant>
 #include <vector>
 
+#include "common/traits.h"
+
 namespace common
 {
 
@@ -87,8 +87,8 @@ class stream_in_t
 
 protected:
 	const std::vector<uint8_t>& inBuffer;
-	uint64_t inPosition;
-	bool failed;
+	uint64_t inPosition{};
+	bool failed{};
 };
 
 //
@@ -99,7 +99,7 @@ class stream_out_t
 	using integer_t = uint64_t;
 
 public:
-	stream_out_t();
+	stream_out_t() = default;
 
 	template<typename TType>
 	inline void push(const TType& value);
@@ -284,12 +284,46 @@ class stream_out_t
 	std::vector<uint8_t> outBuffer;
 };
 
+// Check if T has a pop method with signature void pop(stream_in_t&)
+template<typename T, typename = void>
+struct has_pop : std::false_type
+{};
+
+template<typename T>
+struct has_pop<T, std::void_t<decltype(std::declval<T>().pop(std::declval<common::stream_in_t&>()))>> : std::true_type
+{};
+
+template<typename T>
+constexpr bool has_pop_v = has_pop<T>::value;
+
+// Check if T has a push method with signature void push(stream_out_t&) const
+template<typename T, typename = void>
+struct has_push : std::false_type
+{};
+
+template<typename T>
+struct has_push<T, std::void_t<decltype(std::declval<const T>().push(std::declval<common::stream_out_t&>()))>> : std::true_type
+{};
+
+template<typename T>
+constexpr bool has_push_v = has_push<T>::value;
+
+// Check if T has an as_tuple() method
+template<typename T, typename = void>
+struct has_as_tuple : std::false_type
+{};
+
+template<typename T>
+struct has_as_tuple<T, std::void_t<decltype(std::declval<T>().as_tuple())>> : std::true_type
+{};
+
+template<typename T>
+constexpr bool has_as_tuple_v = has_as_tuple<T>::value;
+
 //
 
 inline stream_in_t::stream_in_t(const std::vector<uint8_t>& buffer) :
-        inBuffer(buffer),
-        inPosition(0),
-        failed(false)
+        inBuffer(buffer)
 {
 }
 
@@ -310,10 +344,22 @@ inline void stream_in_t::pop(TType& value)
 
 		inPosition += sizeof(TType);
 	}
-	else
+	// Use as_tuple method to deserialize members
+	else if constexpr (has_as_tuple_v<TType>)
+	{
+		auto tuple = value.as_tuple();
+		std::apply([this](auto&... args) { (this->pop(args), ...); }, tuple);
+	}
+	// Use the class's own pop method if it has one with the correct signature
+	else if constexpr (has_pop_v<TType>)
 	{
 		value.pop(*this);
 	}
+	else
+	{
+		static_assert(traits::always_false_v<TType>, "Type TType cannot be deserialized: "
+		                                             "no as_tuple or pop(stream_in_t&) method");
+	}
 }
 
 inline void stream_in_t::pop(char* buffer, uint64_t bufferSize)
@@ -338,7 +384,7 @@ inline void stream_in_t::pop(char* buffer, uint64_t bufferSize)
 
 inline void stream_in_t::pop(std::string& value)
 {
-	std::string::size_type size;
+	std::string::size_type size = 0;
 	pop(size);
 
 	if (this->inBuffer.size() - inPosition < size)
@@ -560,10 +606,6 @@ inline void stream_in_t::popVariant(std::variant<TArgs...>& variant,
 
 //
 
-inline stream_out_t::stream_out_t()
-{
-}
-
 template<typename TType>
 inline void stream_out_t::push(const TType& value)
 {
@@ -573,10 +615,22 @@ inline void stream_out_t::push(const TType& value)
 		auto& data = reinterpret_cast<ByteArray>(value);
 		outBuffer.insert(outBuffer.end(), std::begin(data), std::end(data));
 	}
-	else
+	// Use as_tuple method to serialize members
+	else if constexpr (has_as_tuple_v<TType>)
+	{
+		auto tuple = value.as_tuple();
+		std::apply([this](const auto&... args) { (this->push(args), ...); }, tuple);
+	}
+	// Use the class's own push method if it has one with the correct signature
+	else if constexpr (has_push_v<TType>)
 	{
 		value.push(*this);
 	}
+	else
+	{
+		static_assert(traits::always_false_v<TType>, "Type TType cannot be serialized: "
+		                                             "no as_tuple or push(stream_out_t&) method");
+	}
 }
 
 inline void stream_out_t::push(const char* buffer, uint64_t bufferSize)
diff --git a/common/traits.h b/common/traits.h
new file mode 100644
index 00000000..d8503f53
--- /dev/null
+++ b/common/traits.h
@@ -0,0 +1,96 @@
+#pragma once
+
+#include <functional>
+#include <iterator>
+#include <optional>
+#include <set>
+#include <type_traits>
+#include <variant>
+#include <vector>
+
+namespace traits
+{
+
+template<typename>
+struct always_false : std::false_type
+{};
+
+template<typename T>
+inline constexpr bool always_false_v = always_false<T>::value;
+
+template<typename T>
+struct is_optional : std::false_type
+{};
+
+template<typename T>
+struct is_optional<std::optional<T>> : std::true_type
+{};
+
+template<typename T>
+inline constexpr bool is_optional_v = is_optional<T>::value;
+
+template<typename T>
+struct is_variant : std::false_type
+{};
+
+template<typename... Types>
+struct is_variant<std::variant<Types...>> : std::true_type
+{};
+
+template<typename T>
+inline constexpr bool is_variant_v = is_variant<T>::value;
+
+template<typename T, typename = void>
+struct is_container : std::false_type
+{};
+
+/*
+ * Checks:
+ * Whether std::begin(T&), std::end(T&) and std::empty(T&) are valid expressions.
+ * Whether the result of std::begin(T&) can be dereferenced (i.e., *std::begin(T&) is valid)
+ */
+template<typename T>
+struct is_container<T,
+                    std::void_t<
+                            decltype(std::begin(std::declval<T&>())),
+                            decltype(std::end(std::declval<T&>())),
+                            decltype(std::empty(std::declval<T&>())),
+                            decltype(*std::begin(std::declval<T&>()))>> : std::true_type
+{};
+
+template<typename T>
+inline constexpr bool is_container_v = is_container<T>::value;
+
+template<typename T>
+struct is_vector : std::false_type
+{};
+
+template<typename T, typename Alloc>
+struct is_vector<std::vector<T, Alloc>> : std::true_type
+{};
+
+template<typename T>
+inline constexpr bool is_vector_v = is_vector<T>::value;
+
+template<typename T>
+struct is_set : std::false_type
+{};
+
+template<typename Key, typename Compare, typename Allocator>
+struct is_set<std::set<Key, Compare, Allocator>> : std::true_type
+{};
+
+template<typename T>
+inline constexpr bool is_set_v = is_set<T>::value;
+
+template<typename T>
+struct function
+{
+	template<typename R, typename... Args>
+	static std::tuple<Args...> pro_args(std::function<R(Args...)>);
+
+	using args = decltype(pro_args(std::function{std::declval<T>()}));
+};
+
+}
+// namespace utils
diff --git a/common/tsc_deltas.h b/common/tsc_deltas.h
index 9e503797..0bbcf34e 100644
--- a/common/tsc_deltas.h
+++ b/common/tsc_deltas.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <algorithm>
+#include <array>
 #include <climits>
 #include <cstdint>
 #include <rte_branch_prediction.h>
@@ -10,16 +12,15 @@
 
 #include "common/define.h"
 
-#define YANET_TSC_BINS_SHIFT 2
-#define YANET_TSC_BINS_N 4
+constexpr auto YANET_TSC_BINS_SHIFT = 2;
+constexpr auto YANET_TSC_BINS_N = 4;
 
-namespace dataplane
+namespace dataplane::perf
 {
 
-namespace perf
-{
+using CountersArray = std::array<uint16_t, YANET_TSC_BINS_N>;
 
-struct tsc_base_values
+struct alignas(2 * RTE_CACHE_LINE_SIZE) tsc_base_values
 {
 	uint32_t logicalPort_ingress_handle = 18;
 	uint32_t acl_ingress_handle4 = 0;
@@ -46,39 +47,40 @@ struct tsc_base_values
 	uint32_t acl_egress_handle6 = 0;
 	uint32_t logicalPort_egress_handle = 0;
 	uint32_t controlPlane_handle = 0;
-} __attribute__((__aligned__(2 * RTE_CACHE_LINE_SIZE)));
+};
 
-struct tsc_deltas
+struct alignas(2 * RTE_CACHE_LINE_SIZE) tsc_deltas
 {
 	uint64_t iter_num;
-	uint16_t logicalPort_ingress_handle[YANET_TSC_BINS_N];
-	uint16_t acl_ingress_handle4[YANET_TSC_BINS_N];
-	uint16_t acl_ingress_handle6[YANET_TSC_BINS_N];
-	uint16_t tun64_ipv4_handle[YANET_TSC_BINS_N];
-	uint16_t tun64_ipv6_handle[YANET_TSC_BINS_N];
-	uint16_t route_handle4[YANET_TSC_BINS_N];
-	uint16_t route_handle6[YANET_TSC_BINS_N];
-
-	uint16_t decap_handle[YANET_TSC_BINS_N];
-	uint16_t nat64stateful_lan_handle[YANET_TSC_BINS_N];
-	uint16_t nat64stateful_wan_handle[YANET_TSC_BINS_N];
-	uint16_t nat64stateless_egress_handle[YANET_TSC_BINS_N];
-	uint16_t nat64stateless_ingress_handle[YANET_TSC_BINS_N];
-	uint16_t nat46clat_lan_handle[YANET_TSC_BINS_N];
-	uint16_t nat46clat_wan_handle[YANET_TSC_BINS_N];
-	uint16_t balancer_handle[YANET_TSC_BINS_N];
-
-	uint16_t balancer_icmp_reply_handle[YANET_TSC_BINS_N];
-	uint16_t balancer_icmp_forward_handle[YANET_TSC_BINS_N];
-	uint16_t route_tunnel_handle4[YANET_TSC_BINS_N];
-	uint16_t route_tunnel_handle6[YANET_TSC_BINS_N];
-	uint16_t acl_egress_handle4[YANET_TSC_BINS_N];
-	uint16_t acl_egress_handle6[YANET_TSC_BINS_N];
-	uint16_t logicalPort_egress_handle[YANET_TSC_BINS_N];
-
-	uint16_t controlPlane_handle[YANET_TSC_BINS_N];
-
-	YANET_ALWAYS_INLINE void write(uint64_t& tsc_start, uint32_t stack_size, uint16_t bins[YANET_TSC_BINS_N], uint32_t base)
+	CountersArray logicalPort_ingress_handle{};
+
+	CountersArray acl_ingress_handle4{};
+	CountersArray acl_ingress_handle6{};
+	CountersArray tun64_ipv4_handle{};
+	CountersArray tun64_ipv6_handle{};
+	CountersArray route_handle4{};
+	CountersArray route_handle6{};
+
+	CountersArray decap_handle{};
+	CountersArray nat64stateful_lan_handle{};
+	CountersArray nat64stateful_wan_handle{};
+	CountersArray nat64stateless_egress_handle{};
+	CountersArray nat64stateless_ingress_handle{};
+	CountersArray nat46clat_lan_handle{};
+	CountersArray nat46clat_wan_handle{};
+	CountersArray balancer_handle{};
+
+	CountersArray balancer_icmp_reply_handle{};
+	CountersArray balancer_icmp_forward_handle{};
+	CountersArray route_tunnel_handle4{};
+	CountersArray route_tunnel_handle6{};
+	CountersArray acl_egress_handle4{};
+	CountersArray acl_egress_handle6{};
+	CountersArray logicalPort_egress_handle{};
+
+	CountersArray controlPlane_handle{};
+
+	YANET_ALWAYS_INLINE void write(uint64_t& tsc_start, uint32_t stack_size, CountersArray& bins, uint32_t base)
 	{
 		if (!tsc_start || unlikely(stack_size == 0))
 		{
@@ -86,12 +88,12 @@ struct tsc_deltas
 		}
 
 		auto tsc_end = rte_get_tsc_cycles();
-		auto shifted_delta = (int64_t)((tsc_end - tsc_start) / stack_size) - base;
+		auto shifted_delta = static_cast<int64_t>((tsc_end - tsc_start) / stack_size) - base;
 
 		if (shifted_delta > 0)
 		{
-			int floor_log_4 = (sizeof(uint64_t) * CHAR_BIT - _lzcnt_u64(shifted_delta) - 1) >> 1;
-			int bin_idx = std::min(std::max(floor_log_4 - YANET_TSC_BINS_SHIFT, 0), 4 - 1);
+			uint16_t floor_log_4 = (sizeof(uint64_t) * CHAR_BIT - _lzcnt_u64(shifted_delta) - 1) >> 1;
+			uint16_t bin_idx = std::clamp(floor_log_4 - YANET_TSC_BINS_SHIFT, 0, YANET_TSC_BINS_N - 1);
 			bins[bin_idx]++;
 		}
 		else
@@ -102,14 +104,35 @@ struct tsc_deltas
 		tsc_start = tsc_end;
 	}
 
-} __attribute__((__aligned__(2 * RTE_CACHE_LINE_SIZE)));
-
-static_assert(sizeof(tsc_deltas) <= 8 * RTE_CACHE_LINE_SIZE,
-              "too many deltas");
-
-static_assert(std::is_pod_v<tsc_deltas> == true,
-              "tsc structure is not pod");
-
-}
+	[[nodiscard]] auto as_tuple() const
+	{
+		return std::tie(logicalPort_ingress_handle,
+		                acl_ingress_handle4,
+		                acl_ingress_handle6,
+		                tun64_ipv4_handle,
+		                tun64_ipv6_handle,
+		                route_handle4,
+		                route_handle6,
+		                decap_handle,
+		                nat64stateful_lan_handle,
+		                nat64stateful_wan_handle,
+		                nat64stateless_egress_handle,
+		                nat64stateless_ingress_handle,
+		                nat46clat_lan_handle,
+		                nat46clat_wan_handle,
+		                balancer_handle,
+		                balancer_icmp_reply_handle,
+		                balancer_icmp_forward_handle,
+		                route_tunnel_handle4,
+		                route_tunnel_handle6,
+		                acl_egress_handle4,
+		                acl_egress_handle6,
+		                logicalPort_egress_handle,
+		                controlPlane_handle);
+	}
+};
 
+static_assert(sizeof(tsc_deltas) <= 8 * RTE_CACHE_LINE_SIZE, "tsc_deltas size exceeds cache line size");
+static_assert(std::is_trivially_copyable<tsc_deltas>::value, "tsc_deltas should be trivially copyable");
+static_assert(std::is_standard_layout<tsc_deltas>::value, "tsc_deltas should have a standard layout");
 }
diff --git a/common/tuple.h b/common/tuple.h
index 68058c1c..daef539c 100644
--- a/common/tuple.h
+++ b/common/tuple.h
@@ -126,4 +126,78 @@ struct IndexOf<T, std::tuple<Types...>>
 	static constexpr std::size_t value = Helper<0>::value();
 };
 
+/**
+ * @brief Helper to get the size of the first tuple in a parameter pack.
+ *
+ * This function extracts the size of the first tuple in the parameter pack `Tuples`.
+ *
+ * @tparam Tuples The types of the tuples.
+ * @return The size of the first tuple.
+ */
+template<typename... Tuples>
+constexpr std::size_t get_first_tuple_size()
+{
+	static_assert(sizeof...(Tuples) > 0, "At least one tuple is required.");
+	return std::tuple_size_v<std::decay_t<std::tuple_element_t<0, std::tuple<Tuples...>>>>;
+}
+
+template<std::size_t I, std::size_t N, typename Func, typename... Tuples>
+static void zip_apply_helper(Func&& f, Tuples&&... tuples)
+{
+	if constexpr (I < N)
+	{
+		f(std::get<I>(std::forward<Tuples>(tuples))...);
+		zip_apply_helper<I + 1, N>(std::forward<Func>(f), std::forward<Tuples>(tuples)...);
+	}
+}
+
+/**
+ * @brief Applies a function to corresponding elements of multiple tuples.
+ *
+ * The function `f` should be callable with the elements of the tuples at each index.
+ * This function works with any number of tuples, as long as they are all the same size.
+ *
+ * Example:
+ * ```
+ * auto t1 = std::make_tuple(1, 2, 3);
+ * auto t2 = std::make_tuple(4, 5, 6);
+ * zip_apply([](auto a, auto b) {  do something with a and b }, t1, t2);
+ * ```
+ *
+ * @tparam Func The type of the function to apply.
+ * @tparam Tuples The types of the tuples.
+ * @param f The function to apply.
+ * @param tuples The tuples to iterate over.
+ */
+template<typename Func, typename... Tuples>
+inline void zip_apply(Func&& f, Tuples&&... tuples)
+{
+	constexpr std::size_t tuple_size = get_first_tuple_size<Tuples...>();
+	static_assert((... && (std::tuple_size_v<std::decay_t<Tuples>> == tuple_size)), "All tuples must have the same size.");
+
+	zip_apply_helper<0, tuple_size>(std::forward<Func>(f), std::forward<Tuples>(tuples)...);
+}
+
+template<typename... Ts>
+constexpr auto decay_types(std::tuple<Ts...> const&) -> std::tuple<std::decay_t<Ts>...>;
+
+/**
+ * @brief Decays the types of a tuple's elements.
+ *
+ * It removes any const, volatile, and reference qualifiers from the element
+ * types and performs array-to-pointer and function-to-pointer conversions.
+ *
+ * Example usage:
+ * ```
+ * std::tuple<const int&, float, double> t;
+ * using DecayedTuple = decay_tuple<decltype(t)>;
+ * // DecayedTuple is std::tuple<int, float, double>
+ * ```
+ *
+ * @tparam T The type of the tuple to decay.
+ * @return A tuple type with decayed element types.
+ */
+template<typename T>
+using decay_tuple = decltype(decay_types(std::declval<T>()));
+
 } // namespace utils
diff --git a/common/type.h b/common/type.h
index 71cb910b..051ef803 100644
--- a/common/type.h
+++ b/common/type.h
@@ -8,11 +8,10 @@
 #include <vector>
 
 #include <arpa/inet.h>
-#include <inttypes.h>
 #include <memory.h>
 #include <nlohmann/json.hpp>
 
-#include "config.h"
+#include "config.release.h"
 #include "ctree.h"
 #include "define.h"
 #include "stream.h"
@@ -62,45 +61,51 @@ class default_value_t
 	using this_type = default_value_t<type_t, default_value>;
 
 public:
-	inline default_value_t() :
+	default_value_t() :
 	        value(default_value)
 	{
 	}
 
-	inline default_value_t(const type_t& value) :
+	default_value_t(const type_t& value) :
 	        value(value)
 	{
 	}
 
-	inline operator const type_t&() const
+	operator const type_t&() const
 	{
 		return value;
 	}
 
-	inline this_type& operator+=(const this_type& second)
+	this_type& operator+=(const this_type& second)
 	{
 		this->value += second.value;
 		return *this;
 	}
 
-	inline this_type& operator-=(const this_type& second)
+	this_type& operator-=(const this_type& second)
 	{
 		this->value -= second.value;
 		return *this;
 	}
 
-	inline this_type& operator++()
+	this_type& operator++()
 	{
 		this->value++;
 		return *this;
 	}
 
-	inline this_type& operator--()
+	this_type& operator--()
 	{
 		this->value--;
 		return *this;
 	}
 
+	template<typename U = type_t, typename = std::enable_if_t<std::is_arithmetic_v<U>>>
+	operator std::string() const
+	{
+		return std::to_string(value);
+	}
+
 public:
 	type_t value;
 };
@@ -121,9 +126,11 @@ constexpr inline uint32_t unlabelled = 3;
 class uint
 {
 public:
-	uint(const std::string& string)
+	uint() = default;
+
+	uint(const std::string& string) :
+	        value(std::stoull(string, nullptr, 0))
 	{
-		value = std::stoull(string, nullptr, 0);
 	}
 
 	constexpr operator const uint64_t&() const
@@ -137,7 +144,7 @@ class uint
 		return std::to_string(value);
 	}
 
-	uint64_t value;
+	uint64_t value{};
 };
 
 class mac_address_t
@@ -199,12 +206,12 @@ class mac_address_t
 		return address < second.address;
 	}
 
-	constexpr operator const std::array<uint8_t, 6> &() const
+	constexpr operator const std::array<uint8_t, 6>&() const
 	{
 		return address;
 	}
 
-	constexpr operator std::array<uint8_t, 6> &()
+	constexpr operator std::array<uint8_t, 6>&()
 	{
 		return address;
 	}
@@ -215,12 +222,12 @@ class mac_address_t
 	}
 
 public:
-	bool is_default() const
+	[[nodiscard]] bool is_default() const
 	{
 		return *this == mac_address_t();
 	}
 
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		char buffer[64];
 		snprintf(buffer, 64, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", address[0], address[1], address[2], address[3], address[4], address[5]);
@@ -232,20 +239,12 @@ class mac_address_t
 		return address.data();
 	}
 
-	const uint8_t* data() const
+	[[nodiscard]] const uint8_t* data() const
 	{
 		return address.data();
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(address);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(address);
-	}
+	SERIALIZABLE(address);
 
 protected:
 	std::array<uint8_t, 6> address;
@@ -303,14 +302,14 @@ class ipv4_address_t
 	}
 
 public:
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		char buffer[64];
 		snprintf(buffer, 64, "%u.%u.%u.%u", (address >> 24) & 0xFF, (address >> 16) & 0xFF, (address >> 8) & 0xFF, address & 0xFF);
 		return buffer;
 	}
 
-	constexpr ipv4_address_t applyMask(const uint8_t& mask) const
+	[[nodiscard]] constexpr ipv4_address_t applyMask(const uint8_t& mask) const
 	{
 		if (mask == 0 ||
 		    mask > 32)
@@ -321,7 +320,7 @@ class ipv4_address_t
 		return {address & (0xFFFFFFFFu << (32u - mask))};
 	}
 
-	constexpr std::tuple<ipv4_address_t, ipv4_address_t> splitNetwork(const uint8_t& mask) const
+	[[nodiscard]] constexpr std::tuple<ipv4_address_t, ipv4_address_t> splitNetwork(const uint8_t& mask) const
 	{
 		if (mask >= 32)
 		{
@@ -339,20 +338,12 @@ class ipv4_address_t
 		address &= ~((!bit) << (31 - index));
 	}
 
-	uint8_t get_bit(const uint32_t& index) const
+	[[nodiscard]] uint8_t get_bit(const uint32_t& index) const
 	{
 		return (address >> (31 - index)) & 1;
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(address);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(address);
-	}
+	SERIALIZABLE(address);
 
 protected:
 	uint32_t address;
@@ -422,12 +413,12 @@ class ipv6_address_t
 		return !memcmp(address.data(), second.address.data(), address.size());
 	}
 
-	constexpr operator const std::array<uint8_t, 16> &() const
+	constexpr operator const std::array<uint8_t, 16>&() const
 	{
 		return address;
 	}
 
-	constexpr operator std::array<uint8_t, 16> &()
+	constexpr operator std::array<uint8_t, 16>&()
 	{
 		return address;
 	}
@@ -438,7 +429,7 @@ class ipv6_address_t
 	}
 
 public:
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		char buffer[256];
 		inet_ntop(AF_INET6, address.data(), buffer, sizeof(buffer));
@@ -446,7 +437,7 @@ class ipv6_address_t
 		return buffer;
 	}
 
-	ipv6_address_t applyMask(const uint8_t& mask) const
+	[[nodiscard]] ipv6_address_t applyMask(const uint8_t& mask) const
 	{
 		if (mask == 0 ||
 		    mask > 128)
@@ -470,12 +461,12 @@ class ipv6_address_t
 		return {address0, address64};
 	}
 
-	uint128_t getAddress128() const
+	[[nodiscard]] uint128_t getAddress128() const
 	{
 		return ((uint128_t)(getAddress64(0)) << 64) + ((uint128_t)(getAddress64(64)));
 	}
 
-	uint64_t getAddress64(const uint8_t& offset) const
+	[[nodiscard]] uint64_t getAddress64(const uint8_t& offset) const
 	{
 		if (offset % 8 ||
 		    offset > 128 - 64)
@@ -486,7 +477,7 @@ class ipv6_address_t
 		return be64toh(*(uint64_t*)&address[offset / 8]);
 	}
 
-	uint32_t getAddress32(const uint8_t& offset) const
+	[[nodiscard]] uint32_t getAddress32(const uint8_t& offset) const
 	{
 		if (offset % 8 ||
 		    offset > 128 - 32)
@@ -497,12 +488,12 @@ class ipv6_address_t
 		return be32toh(*(uint32_t*)&address[offset / 8]);
 	}
 
-	ipv4_address_t get_mapped_ipv4_address() const
+	[[nodiscard]] ipv4_address_t get_mapped_ipv4_address() const
 	{
 		return ipv4_address_t(getAddress32(96));
 	}
 
-	constexpr const uint8_t* data() const
+	[[nodiscard]] constexpr const uint8_t* data() const
 	{
 		return address.data();
 	}
@@ -519,26 +510,18 @@ class ipv6_address_t
 		byte &= ~((!bit) << (7 - (index % 8)));
 	}
 
-	uint8_t get_bit(const uint32_t& index) const
+	[[nodiscard]] uint8_t get_bit(const uint32_t& index) const
 	{
 		uint32_t address = getAddress32((index / 32) * 32);
 		return (address >> (31 - (index % 32))) & 1;
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(address);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(address);
-	}
+	SERIALIZABLE(address);
 
 	/// Returns true if this is a multicast address (ff00::/8).
 	///
 	/// This property is defined by IETF RFC 4291.
-	constexpr bool is_multicast() const
+	[[nodiscard]] constexpr bool is_multicast() const
 	{
 		return (address[0] & 0xff) == 0xff;
 	}
@@ -550,9 +533,7 @@ class ipv6_address_t
 class ip_address_t
 {
 public:
-	constexpr ip_address_t()
-	{
-	}
+	constexpr ip_address_t() = default;
 
 	ip_address_t(const uint8_t ip_version, const uint8_t* bytes)
 	{
@@ -612,12 +593,12 @@ class ip_address_t
 		return !(address == second.address);
 	}
 
-	constexpr operator const std::variant<ipv4_address_t, ipv6_address_t> &() const
+	constexpr operator const std::variant<ipv4_address_t, ipv6_address_t>&() const
 	{
 		return address;
 	}
 
-	constexpr operator std::variant<ipv4_address_t, ipv6_address_t> &()
+	constexpr operator std::variant<ipv4_address_t, ipv6_address_t>&()
 	{
 		return address;
 	}
@@ -628,7 +609,7 @@ class ip_address_t
 	}
 
 public:
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		std::string string;
 
@@ -640,12 +621,12 @@ class ip_address_t
 		return string;
 	}
 
-	constexpr bool is_ipv4() const
+	[[nodiscard]] constexpr bool is_ipv4() const
 	{
 		return std::holds_alternative<ipv4_address_t>(address);
 	}
 
-	constexpr bool is_ipv6() const
+	[[nodiscard]] constexpr bool is_ipv6() const
 	{
 		return std::holds_alternative<ipv6_address_t>(address);
 	}
@@ -655,7 +636,7 @@ class ip_address_t
 		return std::get<ipv4_address_t>(address);
 	}
 
-	const ipv4_address_t& get_ipv4() const
+	[[nodiscard]] const ipv4_address_t& get_ipv4() const
 	{
 		return std::get<ipv4_address_t>(address);
 	}
@@ -665,12 +646,12 @@ class ip_address_t
 		return std::get<ipv6_address_t>(address);
 	}
 
-	const ipv6_address_t& get_ipv6() const
+	[[nodiscard]] const ipv6_address_t& get_ipv6() const
 	{
 		return std::get<ipv6_address_t>(address);
 	}
 
-	bool is_default() const
+	[[nodiscard]] bool is_default() const
 	{
 		if (is_ipv4() &&
 		    get_ipv4() == ipv4_address_t())
@@ -688,7 +669,7 @@ class ip_address_t
 		}
 	}
 
-	ip_address_t applyMask(const uint8_t& mask) const
+	[[nodiscard]] ip_address_t applyMask(const uint8_t& mask) const
 	{
 		if (is_ipv4())
 		{
@@ -700,15 +681,7 @@ class ip_address_t
 		}
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(address);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(address);
-	}
+	SERIALIZABLE(address);
 
 protected:
 	std::variant<ipv4_address_t, ipv6_address_t> address;
@@ -757,12 +730,12 @@ class ipv4_prefix_t
 		return prefix > second.prefix;
 	}
 
-	constexpr operator const std::tuple<ipv4_address_t, uint8_t> &() const
+	constexpr operator const std::tuple<ipv4_address_t, uint8_t>&() const
 	{
 		return prefix;
 	}
 
-	constexpr operator std::tuple<ipv4_address_t, uint8_t> &()
+	constexpr operator std::tuple<ipv4_address_t, uint8_t>&()
 	{
 		return prefix;
 	}
@@ -773,7 +746,7 @@ class ipv4_prefix_t
 	}
 
 public:
-	constexpr const ipv4_address_t& address() const
+	[[nodiscard]] constexpr const ipv4_address_t& address() const
 	{
 		return std::get<0>(prefix);
 	}
@@ -783,7 +756,7 @@ class ipv4_prefix_t
 		return std::get<0>(prefix);
 	}
 
-	constexpr const uint8_t& mask() const
+	[[nodiscard]] constexpr const uint8_t& mask() const
 	{
 		return std::get<1>(prefix);
 	}
@@ -793,23 +766,23 @@ class ipv4_prefix_t
 		return std::get<1>(prefix);
 	}
 
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		return address().toString() + "/" + std::to_string(mask());
 	}
 
-	constexpr bool isValid() const
+	[[nodiscard]] constexpr bool isValid() const
 	{
 		return mask() <= 32 &&
 		       address().applyMask(mask()) == address();
 	}
 
-	constexpr ipv4_prefix_t applyMask(const uint8_t& mask) const
+	[[nodiscard]] constexpr ipv4_prefix_t applyMask(const uint8_t& mask) const
 	{
 		return {address().applyMask(mask), mask};
 	}
 
-	constexpr std::tuple<ipv4_prefix_t, ipv4_prefix_t> splitNetwork() const
+	[[nodiscard]] constexpr std::tuple<ipv4_prefix_t, ipv4_prefix_t> splitNetwork() const
 	{
 		if (mask() >= 32)
 		{
@@ -821,17 +794,9 @@ class ipv4_prefix_t
 		        {address() | (1u << (32u - mask() - 1u)), (uint8_t)(mask() + 1)}};
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(prefix);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(prefix);
-	}
+	SERIALIZABLE(prefix);
 
-	bool subnetOf(const ipv4_prefix_t& other) const
+	[[nodiscard]] bool subnetOf(const ipv4_prefix_t& other) const
 	{
 		if (mask() < other.mask())
 		{
@@ -841,7 +806,7 @@ class ipv4_prefix_t
 		return address().applyMask(other.mask()) == other.address();
 	}
 
-	bool subnetFor(const ipv4_address_t& other) const
+	[[nodiscard]] bool subnetFor(const ipv4_address_t& other) const
 	{
 		return other.applyMask(mask()) == address().applyMask(mask());
 	}
@@ -853,9 +818,7 @@ class ipv4_prefix_t
 class ipv4_prefix_with_announces_t
 {
 public:
-	ipv4_prefix_with_announces_t()
-	{
-	}
+	ipv4_prefix_with_announces_t() = default;
 
 	ipv4_prefix_with_announces_t(const nlohmann::json& prefixJson)
 	{
@@ -912,17 +875,7 @@ class ipv4_prefix_with_announces_t
 		return prefix < second.prefix;
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(prefix);
-		stream.pop(announces);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(prefix);
-		stream.push(announces);
-	}
+	SERIALIZABLE(prefix, announces);
 
 public:
 	ipv4_prefix_t prefix;
@@ -972,12 +925,12 @@ class ipv6_prefix_t
 		return prefix > second.prefix;
 	}
 
-	constexpr operator const std::tuple<ipv6_address_t, uint8_t> &() const
+	constexpr operator const std::tuple<ipv6_address_t, uint8_t>&() const
 	{
 		return prefix;
 	}
 
-	constexpr operator std::tuple<ipv6_address_t, uint8_t> &()
+	constexpr operator std::tuple<ipv6_address_t, uint8_t>&()
 	{
 		return prefix;
 	}
@@ -988,7 +941,7 @@ class ipv6_prefix_t
 	}
 
 public:
-	constexpr const ipv6_address_t& address() const
+	[[nodiscard]] constexpr const ipv6_address_t& address() const
 	{
 		return std::get<0>(prefix);
 	}
@@ -998,7 +951,7 @@ class ipv6_prefix_t
 		return std::get<0>(prefix);
 	}
 
-	constexpr const uint8_t& mask() const
+	[[nodiscard]] constexpr const uint8_t& mask() const
 	{
 		return std::get<1>(prefix);
 	}
@@ -1008,12 +961,12 @@ class ipv6_prefix_t
 		return std::get<1>(prefix);
 	}
 
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		return address().toString() + "/" + std::to_string(mask());
 	}
 
-	bool isValid() const
+	[[nodiscard]] bool isValid() const
 	{
 		if (mask() > 128)
 		{
@@ -1033,22 +986,22 @@ class ipv6_prefix_t
 		return true;
 	}
 
-	ipv6_prefix_t applyMask(const uint8_t& mask) const
+	[[nodiscard]] ipv6_prefix_t applyMask(const uint8_t& mask) const
 	{
 		return {address().applyMask(mask), mask};
 	}
 
-	uint64_t getAddress64(const uint8_t& offset) const
+	[[nodiscard]] uint64_t getAddress64(const uint8_t& offset) const
 	{
 		return address().getAddress64(offset) & getAddressMask64(offset);
 	}
 
-	uint32_t getAddress32(const uint8_t& offset) const
+	[[nodiscard]] uint32_t getAddress32(const uint8_t& offset) const
 	{
 		return address().getAddress32(offset) & getAddressMask32(offset);
 	}
 
-	uint64_t getAddressMask64(const uint8_t& offset) const
+	[[nodiscard]] uint64_t getAddressMask64(const uint8_t& offset) const
 	{
 		if (offset > 128 - 64)
 		{
@@ -1068,7 +1021,7 @@ class ipv6_prefix_t
 		return 0xFFFFFFFFFFFFFFFFull << (64ull + offset - mask());
 	}
 
-	uint32_t getAddressMask32(const uint8_t& offset) const
+	[[nodiscard]] uint32_t getAddressMask32(const uint8_t& offset) const
 	{
 		if (offset > 128 - 32)
 		{
@@ -1088,22 +1041,14 @@ class ipv6_prefix_t
 		return 0xFFFFFFFFu << (32u + offset - mask());
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(prefix);
-	}
+	SERIALIZABLE(prefix);
 
-	void push(stream_out_t& stream) const
-	{
-		stream.push(prefix);
-	}
-
-	bool subnetFor(const ipv6_address_t& other) const
+	[[nodiscard]] bool subnetFor(const ipv6_address_t& other) const
 	{
 		return other.applyMask(mask()) == address().applyMask(mask());
 	}
 
-	bool subnetOf(const ipv6_prefix_t& other) const
+	[[nodiscard]] bool subnetOf(const ipv6_prefix_t& other) const
 	{
 		if (mask() < other.mask())
 		{
@@ -1180,17 +1125,7 @@ class ipv6_prefix_with_announces_t
 		return prefix < second.prefix;
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(prefix);
-		stream.pop(announces);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(prefix);
-		stream.push(announces);
-	}
+	SERIALIZABLE(prefix, announces);
 
 public:
 	ipv6_prefix_t prefix;
@@ -1200,9 +1135,7 @@ class ipv6_prefix_with_announces_t
 class ip_prefix_t
 {
 public:
-	constexpr ip_prefix_t()
-	{
-	}
+	constexpr ip_prefix_t() = default;
 
 	constexpr ip_prefix_t(const ipv4_prefix_t& prefix) :
 	        prefix(prefix)
@@ -1253,12 +1186,12 @@ class ip_prefix_t
 		return prefix == second.prefix;
 	}
 
-	constexpr operator const std::variant<ipv4_prefix_t, ipv6_prefix_t> &() const
+	constexpr operator const std::variant<ipv4_prefix_t, ipv6_prefix_t>&() const
 	{
 		return prefix;
 	}
 
-	constexpr operator std::variant<ipv4_prefix_t, ipv6_prefix_t> &()
+	constexpr operator std::variant<ipv4_prefix_t, ipv6_prefix_t>&()
 	{
 		return prefix;
 	}
@@ -1269,7 +1202,7 @@ class ip_prefix_t
 	}
 
 public:
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		std::string string;
 
@@ -1281,12 +1214,12 @@ class ip_prefix_t
 		return string;
 	}
 
-	bool is_ipv4() const
+	[[nodiscard]] bool is_ipv4() const
 	{
 		return std::holds_alternative<ipv4_prefix_t>(prefix);
 	}
 
-	bool is_ipv6() const
+	[[nodiscard]] bool is_ipv6() const
 	{
 		return std::holds_alternative<ipv6_prefix_t>(prefix);
 	}
@@ -1296,7 +1229,7 @@ class ip_prefix_t
 		return std::get<ipv4_prefix_t>(prefix);
 	}
 
-	const ipv4_prefix_t& get_ipv4() const
+	[[nodiscard]] const ipv4_prefix_t& get_ipv4() const
 	{
 		return std::get<ipv4_prefix_t>(prefix);
 	}
@@ -1306,7 +1239,7 @@ class ip_prefix_t
 		return std::get<ipv6_prefix_t>(prefix);
 	}
 
-	const ipv6_prefix_t& get_ipv6() const
+	[[nodiscard]] const ipv6_prefix_t& get_ipv6() const
 	{
 		return std::get<ipv6_prefix_t>(prefix);
 	}
@@ -1323,7 +1256,7 @@ class ip_prefix_t
 		}
 	}
 
-	const uint8_t& mask() const
+	[[nodiscard]] const uint8_t& mask() const
 	{
 		if (is_ipv4())
 		{
@@ -1335,7 +1268,7 @@ class ip_prefix_t
 		}
 	}
 
-	bool is_default() const
+	[[nodiscard]] bool is_default() const
 	{
 		if (is_ipv4() &&
 		    get_ipv4() == ipv4_prefix_t())
@@ -1353,7 +1286,7 @@ class ip_prefix_t
 		}
 	}
 
-	bool is_host() const
+	[[nodiscard]] bool is_host() const
 	{
 		if (is_ipv4())
 		{
@@ -1365,7 +1298,7 @@ class ip_prefix_t
 		}
 	}
 
-	ip_prefix_t get_default() const
+	[[nodiscard]] ip_prefix_t get_default() const
 	{
 		if (is_ipv4())
 		{
@@ -1377,7 +1310,7 @@ class ip_prefix_t
 		}
 	}
 
-	ip_address_t address() const
+	[[nodiscard]] ip_address_t address() const
 	{
 		if (is_ipv4())
 		{
@@ -1389,7 +1322,7 @@ class ip_prefix_t
 		}
 	}
 
-	ip_prefix_t applyMask(const uint8_t& mask) const
+	[[nodiscard]] ip_prefix_t applyMask(const uint8_t& mask) const
 	{
 		if (is_ipv4())
 		{
@@ -1401,7 +1334,7 @@ class ip_prefix_t
 		}
 	}
 
-	bool subnetFor(const ip_address_t& other) const
+	[[nodiscard]] bool subnetFor(const ip_address_t& other) const
 	{
 		if (is_ipv4() && other.is_ipv4())
 		{
@@ -1414,15 +1347,7 @@ class ip_prefix_t
 		return false;
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(prefix);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(prefix);
-	}
+	SERIALIZABLE(prefix);
 
 protected:
 	std::variant<ipv4_prefix_t, ipv6_prefix_t> prefix;
@@ -1433,9 +1358,7 @@ class ip_prefix_with_announces_t
 public:
 	using variant_t = std::variant<ipv4_prefix_with_announces_t, ipv6_prefix_with_announces_t>;
 
-	ip_prefix_with_announces_t()
-	{
-	}
+	ip_prefix_with_announces_t() = default;
 
 	ip_prefix_with_announces_t(const nlohmann::json& prefixJson)
 	{
@@ -1488,7 +1411,7 @@ class ip_prefix_with_announces_t
 	}
 
 public:
-	ip_prefix_t get_prefix() const
+	[[nodiscard]] ip_prefix_t get_prefix() const
 	{
 		if (std::holds_alternative<ipv4_prefix_with_announces_t>(prefix))
 		{
@@ -1500,15 +1423,7 @@ class ip_prefix_with_announces_t
 		}
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(prefix);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(prefix);
-	}
+	SERIALIZABLE(prefix);
 
 protected:
 	variant_t prefix;
@@ -1572,20 +1487,12 @@ class community_t
 	}
 
 public:
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		return std::to_string(value >> 16) + ":" + std::to_string(value & 0xFFFF);
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(value);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(value);
-	}
+	SERIALIZABLE(value);
 
 protected:
 	uint32_t value;
@@ -1641,12 +1548,12 @@ class large_community_t
 		return value == second.value;
 	}
 
-	constexpr operator const std::array<uint32_t, 3> &() const
+	constexpr operator const std::array<uint32_t, 3>&() const
 	{
 		return value;
 	}
 
-	constexpr operator std::array<uint32_t, 3> &()
+	constexpr operator std::array<uint32_t, 3>&()
 	{
 		return value;
 	}
@@ -1657,20 +1564,12 @@ class large_community_t
 	}
 
 public:
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		return std::to_string(value[0]) + ":" + std::to_string(value[1]) + ":" + std::to_string(value[2]);
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(value);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(value);
-	}
+	SERIALIZABLE(value);
 
 public:
 	std::array<uint32_t, 3> value;
@@ -1679,44 +1578,42 @@ class large_community_t
 class values_t
 {
 public:
-	values_t()
-	{
-	}
+	values_t() = default;
 
-	template<typename... args_T>
-	values_t(const args_T&... args)
+	template<typename... Args>
+	values_t(const Args&... args)
 	{
 		insertHelper(args...);
 	}
 
-	operator const std::set<uint64_t> &() const
+	operator const std::set<uint64_t>&() const
 	{
 		return values;
 	}
 
-	operator std::set<uint64_t> &()
+	operator std::set<uint64_t>&()
 	{
 		return values;
 	}
 
-	auto begin() const
+	[[nodiscard]] auto begin() const
 	{
 		return values.begin();
 	}
 
-	auto end() const
+	[[nodiscard]] auto end() const
 	{
 		return values.end();
 	}
 
 protected:
-	template<typename arg0_T, typename... args_T>
+	template<typename arg0_T, typename... Args>
 	void insertHelper(const arg0_T& arg0,
-	                  const args_T&... args)
+	                  const Args&... args)
 	{
 		values.emplace(arg0);
 
-		if constexpr (sizeof...(args_T))
+		if constexpr (sizeof...(Args))
 		{
 			insertHelper(args...);
 		}
@@ -1729,9 +1626,7 @@ class values_t
 class range_t
 {
 public:
-	constexpr range_t()
-	{
-	}
+	constexpr range_t() = default;
 
 	constexpr range_t(const uint64_t& value) :
 	        range(value, value)
@@ -1773,12 +1668,12 @@ class range_t
 		return range < second.range;
 	}
 
-	constexpr operator const std::tuple<uint64_t, uint64_t> &() const
+	constexpr operator const std::tuple<uint64_t, uint64_t>&() const
 	{
 		return range;
 	}
 
-	constexpr operator std::tuple<uint64_t, uint64_t> &()
+	constexpr operator std::tuple<uint64_t, uint64_t>&()
 	{
 		return range;
 	}
@@ -1789,7 +1684,7 @@ class range_t
 	}
 
 public:
-	std::string toString() const
+	[[nodiscard]] std::string toString() const
 	{
 		return std::to_string(from()) + (from() == to() ? "" : "-" + std::to_string(to()));
 	}
@@ -1799,7 +1694,7 @@ class range_t
 		return std::get<0>(range);
 	}
 
-	const uint64_t& from() const
+	[[nodiscard]] const uint64_t& from() const
 	{
 		return std::get<0>(range);
 	}
@@ -1809,20 +1704,12 @@ class range_t
 		return std::get<1>(range);
 	}
 
-	const uint64_t& to() const
+	[[nodiscard]] const uint64_t& to() const
 	{
 		return std::get<1>(range);
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(range);
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(range);
-	}
+	SERIALIZABLE(range);
 
 protected:
 	std::tuple<uint64_t, uint64_t> range;
@@ -1849,9 +1736,7 @@ class flags_t
 class ranges_t ///< @todo: rename filter_t
 {
 public:
-	ranges_t()
-	{
-	}
+	ranges_t() = default;
 
 	ranges_t(const uint64_t& value)
 	{
@@ -1897,17 +1782,17 @@ class ranges_t ///< @todo: rename filter_t
 		return ranges < second.ranges;
 	}
 
-	auto begin() const
+	[[nodiscard]] auto begin() const
 	{
 		return ranges.begin();
 	}
 
-	auto end() const
+	[[nodiscard]] auto end() const
 	{
 		return ranges.end();
 	}
 
-	bool empty() const
+	[[nodiscard]] bool empty() const
 	{
 		return ranges.empty();
 	}
@@ -1959,7 +1844,7 @@ class ranges_t ///< @todo: rename filter_t
 		ranges = newRanges;
 	}
 
-	bool isIntersect(const ranges_t& second) const
+	[[nodiscard]] bool isIntersect(const ranges_t& second) const
 	{
 		for (const auto& range : ranges)
 		{
@@ -1998,9 +1883,7 @@ constexpr ipv6_prefix_t ipv6_prefix_default = {ipv6_address_default, 0};
 
 //
 
-namespace worker
-{
-namespace stats
+namespace worker::stats
 {
 struct common
 {
@@ -2047,7 +1930,6 @@ struct port
 	uint64_t controlPlane_drops = 0; ///< @todo: DELETE
 };
 }
-}
 
 namespace worker_gc
 {
@@ -2302,7 +2184,6 @@ class tFlow
 {
 public:
 	tFlow() :
-	        type(eFlowType::controlPlane), ///< @todo: drop
 	        flags(0),
 	        counter_id(0)
 	{
@@ -2317,12 +2198,12 @@ class tFlow
 		data.atomic = 0;
 	}
 
-	inline bool operator==(const tFlow& second) const
+	bool operator==(const tFlow& second) const
 	{
 		return std::tie(type_params_atomic, data.atomic) == std::tie(second.type_params_atomic, second.data.atomic);
 	}
 
-	inline bool operator!=(const tFlow& second) const
+	bool operator!=(const tFlow& second) const
 	{
 		return !operator==(second);
 	}
@@ -2356,16 +2237,6 @@ class tFlow
 		return data.atomic;
 	}
 
-	void pop(stream_in_t& stream)
-	{
-		stream.pop(reinterpret_cast<uint8_t(&)[sizeof(*this)]>(*this));
-	}
-
-	void push(stream_out_t& stream) const
-	{
-		stream.push(reinterpret_cast<const uint8_t(&)[sizeof(*this)]>(*this));
-	}
-
 	[[nodiscard]] std::string to_string() const
 	{
 		std::ostringstream oss;
@@ -2383,7 +2254,7 @@ class tFlow
 		uint32_t type_params_atomic;
 		struct
 		{
-			eFlowType type;
+			eFlowType type{eFlowType::controlPlane}; ///< @todo: drop
 			uint8_t flags : 2;
 			uint32_t counter_id : 22;
 		};
@@ -2649,7 +2520,7 @@ struct hash<common::ipv4_address_t>
 {
 	std::size_t operator()(const common::ipv4_address_t& ip_addr) const
 	{
-		const uint32_t ipv4 = static_cast<uint32_t>(ip_addr);
+		const auto ipv4 = static_cast<uint32_t>(ip_addr);
 		return std::hash<uint32_t>()(ipv4);
 	}
 };
diff --git a/common/unittest/shared_memory.cpp b/common/unittest/shared_memory.cpp
index 67e7c971..ce46728a 100644
--- a/common/unittest/shared_memory.cpp
+++ b/common/unittest/shared_memory.cpp
@@ -8,8 +8,8 @@ void TestForSize(void* buffer_writer, void* buffer_reader, size_t size, size_t s
 	ASSERT_TRUE(buffer_reader != nullptr);
 	ASSERT_EQ(size, size_reader);
 
-	uint8_t* buffer_writer8 = reinterpret_cast<uint8_t*>(buffer_writer);
-	uint8_t* buffer_reader8 = reinterpret_cast<uint8_t*>(buffer_reader);
+	auto* buffer_writer8 = reinterpret_cast<uint8_t*>(buffer_writer);
+	auto* buffer_reader8 = reinterpret_cast<uint8_t*>(buffer_reader);
 
 	for (uint64_t index = 0; index < size; index++)
 	{
diff --git a/common/unittest/static_vector.cpp b/common/unittest/static_vector.cpp
index bb4049ab..91033879 100644
--- a/common/unittest/static_vector.cpp
+++ b/common/unittest/static_vector.cpp
@@ -1,7 +1,6 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#define STATIC_VECTOR_USE_EXCEPTIONS
 #include "../static_vector.h"
 
 namespace
@@ -12,7 +11,7 @@ static constexpr std::string_view hw = "Hello World!";
 
 TEST(StaticVector, 001_Basic_element_store)
 {
-	StaticVector<char, hw.length()> v;
+	StaticVector<char, hw.length(), true> v; // Enable exceptions
 	ASSERT_TRUE(v.empty());
 	for (auto& c : hw)
 	{
@@ -47,4 +46,4 @@ TEST(StaticVector, 002_POD_copy_move)
 	ASSERT_TRUE(std::mismatch(v.begin(), v.end(), moved.begin()).first == v.end());
 }
 
-} // namespace
\ No newline at end of file
+} // namespace
diff --git a/common/unittest/tuple.cpp b/common/unittest/tuple.cpp
index 906d2d3c..da3c0399 100644
--- a/common/unittest/tuple.cpp
+++ b/common/unittest/tuple.cpp
@@ -134,4 +134,86 @@ TEST(IndexOf, EmptyTuple)
 	// constexpr std::size_t invalidIndex = IndexOf<int, EmptyTuple>::value;
 }
 
+using utils::get_first_tuple_size;
+
+TEST(TupleSize, GetFirstTupleSize)
+{
+	using Tuple1 = std::tuple<int, double, char>;
+	constexpr std::size_t size1 = get_first_tuple_size<Tuple1>();
+	EXPECT_EQ(size1, 3);
+
+	using Tuple2 = std::tuple<float, bool, long, int, double>;
+	constexpr std::size_t size2 = get_first_tuple_size<Tuple1, Tuple2>();
+	EXPECT_EQ(size2, 3);
+
+	using EmptyTuple = std::tuple<>;
+	constexpr std::size_t size3 = get_first_tuple_size<EmptyTuple>();
+	EXPECT_EQ(size3, 0);
+}
+
+using utils::zip_apply;
+
+TEST(ZipApply, BasicUsage)
+{
+	auto t1 = std::make_tuple(1, 2, 3);
+	auto t2 = std::make_tuple(4, 5, 6);
+	std::vector<int> results;
+
+	auto op = [&](int a, int b) {
+		results.push_back(a + b);
+	};
+
+	zip_apply(op, t1, t2);
+
+	EXPECT_EQ(results.size(), 3u);
+	EXPECT_EQ(results[0], 5);
+	EXPECT_EQ(results[1], 7);
+	EXPECT_EQ(results[2], 9);
+
+	results.clear();
+	auto op2 = [&](int a, int b, int c, int d) {
+		results.push_back(a + b + c + d);
+	};
+
+	zip_apply(op2, t1, t2, t1, t2);
+
+	EXPECT_EQ(results.size(), 3u);
+	EXPECT_EQ(results[0], 10);
+	EXPECT_EQ(results[1], 14);
+	EXPECT_EQ(results[2], 18);
+}
+
+TEST(ZipApply, WorksWithSingleTuple)
+{
+	auto t1 = std::make_tuple(1, 2, 3);
+	std::vector<int> results;
+
+	auto op = [&](int a) {
+		results.push_back(a * 2);
+	};
+
+	zip_apply(op, t1);
+
+	EXPECT_EQ(results.size(), 3u);
+	EXPECT_EQ(results[0], 2);
+	EXPECT_EQ(results[1], 4);
+	EXPECT_EQ(results[2], 6);
+}
+
+TEST(ZipApply, DifferentSizesCompileError)
+{
+	// Expect a compile-time failure due to different tuple sizes
+	// Uncommenting the following lines should trigger a compile-time error:
+	/* auto t1 = std::make_tuple(1, 2); */
+	/* auto t2 = std::make_tuple(3); */
+	/* zip_apply([](int a, int b) {}, t1, t2); */
+}
+
+TEST(ZipApply, NoTuplesCompileError)
+{
+	// Expect a compile-time failure due to no tuples provided
+	// Uncommenting the following lines should trigger a compile-time error:
+	/* zip_apply([]() { }); */
+}
+
 } // namespace
diff --git a/common/utils.h b/common/utils.h
index d979370f..20e20696 100644
--- a/common/utils.h
+++ b/common/utils.h
@@ -1,14 +1,50 @@
-
 #pragma once
 
-#include <type_traits>
+#include <iomanip>
+#include <vector>
 
 namespace utils
 {
 
-template<typename>
-struct always_false : std::false_type
-{};
+// Utility to calculate percentage
+// TODO C++20: use std::type_identity_t to establish non-deduced context
+// Will allow to do `to_percent(4.2, 1)`
+template<typename T>
+inline std::string to_percent(T current, T maximum = 1)
+{
+	double percent = 0.0;
+	if (maximum != 0)
+	{
+		percent = static_cast<double>(current) / static_cast<double>(maximum) * 100.0;
+	}
+
+	std::ostringstream stream;
+	stream << std::fixed << std::setprecision(2) << percent;
+	return stream.str();
+}
+
+// Split a string_view into a vector of strings based on a delimiter
+inline std::vector<std::string> split(const std::string_view str, char delimiter)
+{
+	std::vector<std::string> result;
+	size_t start = 0;
+	size_t end = 0;
+
+	while ((end = str.find(delimiter, start)) != std::string_view::npos)
+	{
+		result.emplace_back(str.substr(start, end - start));
+		start = end + 1;
+	}
+	result.emplace_back(str.substr(start));
+	return result;
+}
+
+// Split for std::string but disabled for const char* to avoid ambiguity
+template<typename T, typename = std::enable_if_t<!std::is_same_v<T, const char*>>>
+inline std::vector<std::string> split(const std::string& str, char delimiter)
+{
+	return split(std::string_view(str), delimiter);
+}
 
 }
 // namespace utils
diff --git a/common/weight.h b/common/weight.h
index 0b882301..20c1fb84 100644
--- a/common/weight.h
+++ b/common/weight.h
@@ -16,7 +16,6 @@ class weight_t
 
 public:
 	weight_t() :
-	        size(0),
 	        current(0)
 	{
 		base.resize(size_T, 0);
@@ -114,7 +113,7 @@ class weight_t
 
 	mutable std::vector<index_type_T> base;
 
-	uint32_t size;
+	uint32_t size{};
 	mutable std::atomic<uint32_t> current;
 };
 
diff --git a/controlplane/acl.cpp b/controlplane/acl.cpp
index 2f02f414..71258421 100644
--- a/controlplane/acl.cpp
+++ b/controlplane/acl.cpp
@@ -7,7 +7,6 @@
 #include <stdexcept>
 #include <string>
 #include <unordered_map>
-#include <unordered_set>
 #include <vector>
 
 #ifdef ACL_DEBUG
@@ -23,14 +22,10 @@
 	}
 
 #include "acl.h"
-#include "acl/bitset.h"
 #include "acl/dict.h"
-#include "acl/network.h"
 #include "acl/rule.h"
 #include "acl_compiler.h"
 
-#include "common/acl.h"
-
 namespace acl
 {
 
@@ -58,8 +53,8 @@ struct dispatcher_rules_t
 			{
 				const auto& network = *item.network;
 
-				filter_network_t* _src = new filter_network_t;
-				filter_network_t* _dst = new filter_network_t;
+				auto* _src = new filter_network_t;
+				auto* _dst = new filter_network_t;
 
 				if (std::holds_alternative<controlplane::base::acl_rule_network_ipv4_t>(network))
 				{
@@ -532,10 +527,10 @@ iface_map_t ifaceMapping(std::map<std::string, controlplane::base::logical_port_
 
 	for (const auto& [route_name, route] : routes)
 	{
-		(void)route_name;
+		YANET_GCC_BUG_UNUSED(route_name);
 		for (const auto& [name, iface] : route.interfaces)
 		{
-			(void)name;
+			YANET_GCC_BUG_UNUSED(name);
 			ret[iface.aclId].emplace(false, iface.nextModule);
 		}
 	}
@@ -546,7 +541,7 @@ iface_map_t ifaceMapping(std::map<std::string, controlplane::base::logical_port_
 // used by acl_lookup
 unwind_result unwind(const std::map<std::string, controlplane::base::acl_t>& acls,
                      const iface_map_t& ifaces,
-                     const std::optional<std::string>& module,
+                     [[maybe_unused]] const std::optional<std::string>& module,
                      const std::optional<std::string>& direction,
                      const std::optional<std::string>& network_source,
                      const std::optional<std::string>& network_destination,
@@ -557,8 +552,6 @@ unwind_result unwind(const std::map<std::string, controlplane::base::acl_t>& acl
                      const std::optional<std::string>& transport_flags,
                      const std::optional<std::string>& in_recordstate)
 {
-	(void)module;
-
 	unwind_result result;
 
 	try
@@ -785,7 +778,7 @@ std::vector<rule_t> unwind_used_rules(const std::map<std::string, controlplane::
 	ids_map_map.emplace(ids_t(), 0);
 
 	result.ids_map.clear();
-	result.ids_map.push_back(ids_t());
+	result.ids_map.emplace_back();
 	std::set<ids_t> ids_overflow;
 
 #ifdef ACL_DEBUG
@@ -847,14 +840,14 @@ std::vector<rule_t> unwind_used_rules(const std::map<std::string, controlplane::
 			if (!rule.ids.empty())
 #endif
 			{
-				result.dispatcher.emplace_back(std::make_tuple(
+				result.dispatcher.emplace_back(
 #ifdef ACL_DEBUG
 				        rule.ids[0],
 #else
 				        FW_DISPATCHER_START_ID,
 #endif
 				        rule.to_string(),
-				        std::string()));
+				        std::string());
 			}
 			ACL_DBGMSG("dispatcher rule: " << rule.to_string());
 		}
@@ -1028,7 +1021,7 @@ uint8_t string_to_proto(const std::string& string)
 
 std::set<uint32_t> lookup(const std::map<std::string, controlplane::base::acl_t>& acls,
                           const iface_map_t& ifaces,
-                          const std::optional<std::string>& module,
+                          [[maybe_unused]] const std::optional<std::string>& module,
                           const std::optional<std::string>& direction,
                           const std::optional<std::string>& network_source,
                           const std::optional<std::string>& network_destination,
@@ -1037,8 +1030,6 @@ std::set<uint32_t> lookup(const std::map<std::string, controlplane::base::acl_t>
                           const std::optional<std::string>& transport_source,
                           const std::optional<std::string>& transport_destination)
 {
-	(void)module;
-
 	std::set<uint32_t> result;
 
 	try
diff --git a/controlplane/acl.h b/controlplane/acl.h
index e3a73405..2822e3a0 100644
--- a/controlplane/acl.h
+++ b/controlplane/acl.h
@@ -3,6 +3,7 @@
 #include <nlohmann/json.hpp>
 
 #include "base.h"
+#include "common/idp.h"
 
 namespace acl
 {
diff --git a/controlplane/acl/bitset.h b/controlplane/acl/bitset.h
index be17730d..f4558a03 100644
--- a/controlplane/acl/bitset.h
+++ b/controlplane/acl/bitset.h
@@ -18,19 +18,19 @@ namespace acl
 struct bitset_t
 {
 public:
-	inline void insert(size_t i)
+	void insert(size_t i)
 	{
 		vals[i / 64] |= ((uint64_t)(1) << (i % 64));
 		first_one = std::min(first_one, i / 64);
 	}
 
-	inline bool operator[](size_t i) const
+	bool operator[](size_t i) const
 	{
 
 		return (vals[i / 64] & ((uint64_t)(1) << (i % 64))) != 0;
 	}
 
-	inline bool empty() const
+	[[nodiscard]] bool empty() const
 	{
 		return first_one == size;
 	}
@@ -41,7 +41,7 @@ struct bitset_t
 		printf("%s", to_string().c_str());
 	}
 
-	std::string to_string() const
+	[[nodiscard]] std::string to_string() const
 	{
 		std::string out;
 		for (size_t i = 0; i < size; ++i)
@@ -59,7 +59,7 @@ struct bitset_t
 	}
 #endif
 
-	inline bitset_t& operator|=(bitset_t const& other)
+	bitset_t& operator|=(bitset_t const& other)
 	{
 		if (other.empty())
 		{
@@ -74,7 +74,7 @@ struct bitset_t
 		return *this;
 	}
 
-	inline bitset_t& operator&=(bitset_t const& other)
+	bitset_t& operator&=(bitset_t const& other)
 	{
 		if (empty())
 		{
@@ -95,14 +95,14 @@ struct bitset_t
 		return *this;
 	}
 
-	friend inline bitset_t operator&(const bitset_t& rs1, const bitset_t& rs2)
+	friend bitset_t operator&(const bitset_t& rs1, const bitset_t& rs2)
 	{
 		bitset_t r = rs1;
 
 		return r &= rs2;
 	}
 
-	friend inline bool operator==(const bitset_t& p1, const bitset_t& p2)
+	friend bool operator==(const bitset_t& p1, const bitset_t& p2)
 	{
 		for (size_t i = p1.start(p2); i < p1.size; ++i)
 		{
@@ -115,12 +115,12 @@ struct bitset_t
 		return true;
 	}
 
-	friend inline bool operator!=(const bitset_t& p1, const bitset_t& p2)
+	friend bool operator!=(const bitset_t& p1, const bitset_t& p2)
 	{
 		return !(p1 == p2);
 	}
 
-	inline std::tuple<size_t, bool> minAnd(const bitset_t& p) const
+	[[nodiscard]] std::tuple<size_t, bool> minAnd(const bitset_t& p) const
 	{
 		for (size_t i = std::max(first_one, p.first_one); i < size; ++i)
 		{
@@ -134,8 +134,8 @@ struct bitset_t
 		return {0, false};
 	}
 
-	inline std::tuple<size_t, bool> minAnd(const bitset_t& p1,
-	                                       const bitset_t& p2) const
+	[[nodiscard]] std::tuple<size_t, bool> minAnd(const bitset_t& p1,
+	                                              const bitset_t& p2) const
 	{
 		for (size_t i = std::max(std::max(first_one, p1.first_one), p2.first_one); i < size; ++i)
 		{
@@ -149,7 +149,7 @@ struct bitset_t
 		return {0, false};
 	}
 
-	inline bool emptyAnd(const bitset_t& p1) const
+	[[nodiscard]] bool emptyAnd(const bitset_t& p1) const
 	{
 		for (size_t i = std::max(first_one, p1.first_one); i < size; ++i)
 		{
@@ -163,7 +163,7 @@ struct bitset_t
 	}
 
 private:
-	size_t start(const bitset_t& p1) const
+	[[nodiscard]] size_t start(const bitset_t& p1) const
 	{
 		return std::min(first_one, p1.first_one);
 	}
@@ -207,7 +207,7 @@ struct bitset_t
 	}
 };
 
-} //namespace acl
+} // namespace acl
 
 namespace std
 {
diff --git a/controlplane/acl/dict.h b/controlplane/acl/dict.h
index 000e905e..62d29e24 100644
--- a/controlplane/acl/dict.h
+++ b/controlplane/acl/dict.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "../acl.h"
-
 #include "bitset.h"
 #include "network.h"
 #include "rule.h"
@@ -44,7 +42,7 @@ bool is_mask_simple(uint128_t mask)
 	bool end_found = false;
 	for (unsigned int i = 1; i <= 16; ++i)
 	{
-		const uint8_t byte = uint8_t((mask >> (128 - i * 8)) & 0xff);
+		const auto byte = uint8_t((mask >> (128 - i * 8)) & 0xff);
 		if (end_found)
 		{
 			if (byte > 0)
@@ -268,7 +266,7 @@ struct rdict_t
 		vec.reserve(map.size());
 		for (auto& v : map)
 		{
-			vec.push_back(v);
+			vec.emplace_back(v);
 		}
 
 		return vec;
@@ -477,7 +475,7 @@ struct id_dict_t
 	{
 	}
 
-	inline void insert(unsigned int id, unsigned int idx)
+	void insert(unsigned int id, unsigned int idx)
 	{
 		if (id >= table.size())
 		{
diff --git a/controlplane/acl/network.h b/controlplane/acl/network.h
index d8bdf260..c5f87d98 100644
--- a/controlplane/acl/network.h
+++ b/controlplane/acl/network.h
@@ -123,17 +123,13 @@ struct network_t
 	}
 
 	network_t(const ipfw::ipv4_prefix_mask_t& pref) :
-	        family(4)
+	        family(4), addr(std::get<0>(pref)), mask(std::get<1>(pref))
 	{
-		addr = std::get<0>(pref);
-		mask = std::get<1>(pref);
 	}
 
 	network_t(const ipfw::ipv6_prefix_mask_t& pref) :
-	        family(6)
+	        family(6), addr(std::get<0>(pref).getAddress128()), mask(std::get<1>(pref).getAddress128())
 	{
-		addr = std::get<0>(pref).getAddress128();
-		mask = std::get<1>(pref).getAddress128();
 	}
 
 	network_t(const common::ip_prefix_t& pref)
@@ -161,7 +157,7 @@ struct network_t
 	{
 	}
 
-	std::string to_string() const
+	[[nodiscard]] std::string to_string() const
 	{
 		std::stringstream ret;
 		if (family == 4)
@@ -194,7 +190,7 @@ struct network_t
 		return std::tie(family, mask, addr) < std::tie(second.family, second.mask, second.addr);
 	}
 
-	network_t normalize() const
+	[[nodiscard]] network_t normalize() const
 	{
 		return {family, addr & mask, mask};
 	}
diff --git a/controlplane/acl/rule.h b/controlplane/acl/rule.h
index 6e03740f..408aaee5 100644
--- a/controlplane/acl/rule.h
+++ b/controlplane/acl/rule.h
@@ -8,7 +8,6 @@
 #include <vector>
 
 #include "common/actions.h"
-#include "libfwparser/fw_parser.h"
 
 #include "network.h"
 
@@ -27,12 +26,12 @@ struct range_t : std::tuple<uint_t, uint_t>
 	inline range_t(unsigned int val) :
 	        std::tuple<uint_t, uint_t>(val, val) {}
 
-	uint_t from() const
+	[[nodiscard]] uint_t from() const
 	{
 		return std::get<0>(*this);
 	}
 
-	uint_t to() const
+	[[nodiscard]] uint_t to() const
 	{
 		return std::get<1>(*this);
 	}
@@ -40,13 +39,12 @@ struct range_t : std::tuple<uint_t, uint_t>
 
 struct filter_base_t
 {
-	unsigned long ref_count;
+	unsigned long ref_count{};
 
-	inline constexpr filter_base_t() :
-	        ref_count(0) {}
-	virtual bool is_none() const = 0;
-	virtual ~filter_base_t() {}
-	virtual std::string to_string() const = 0;
+	inline constexpr filter_base_t() = default;
+	[[nodiscard]] virtual bool is_none() const = 0;
+	virtual ~filter_base_t() = default;
+	[[nodiscard]] virtual std::string to_string() const = 0;
 };
 
 template<typename filter_t>
@@ -80,9 +78,9 @@ struct ref_t
 		ref_inc();
 	}
 
-	inline ref_t(const ref_t& _ref)
+	inline ref_t(const ref_t& _ref) :
+	        filter(_ref.filter)
 	{
-		filter = _ref.filter;
 		ref_inc();
 	}
 
@@ -146,7 +144,7 @@ struct ref_t
 		return filter != nullptr;
 	}
 
-	inline bool is_none() const
+	[[nodiscard]] inline bool is_none() const
 	{
 		return filter ? filter->is_none() : false;
 	}
@@ -182,7 +180,7 @@ struct filter_network_t : filter_base_t
 {
 	std::vector<network_t> networks;
 
-	inline filter_network_t() {}
+	inline filter_network_t() = default;
 
 	filter_network_t(const ipfw::rule_t::address_t& target)
 	{
@@ -200,12 +198,12 @@ struct filter_network_t : filter_base_t
 		networks.emplace_back(std::move(string));
 	}
 
-	virtual bool is_none() const
+	[[nodiscard]] bool is_none() const override
 	{
 		return networks.empty();
 	}
 
-	virtual std::string to_string() const
+	[[nodiscard]] std::string to_string() const override
 	{
 		if (networks.empty())
 		{
@@ -234,7 +232,7 @@ struct filter_network_t : filter_base_t
 
 inline ref_t<filter_network_t> and_op(const ref_t<filter_network_t>& a, const ref_t<filter_network_t>& b)
 {
-	filter_network_t* result = new filter_network_t;
+	auto* result = new filter_network_t;
 
 	for (const auto& a_item : a.filter->networks)
 	{
@@ -270,7 +268,7 @@ struct filter_prm_t : filter_base_t
 {
 	std::vector<range_t<uint_t>> ranges;
 
-	inline filter_prm_t() {}
+	inline filter_prm_t() = default;
 
 	filter_prm_t(const common::ranges_t& _ranges)
 	{
@@ -336,12 +334,12 @@ struct filter_prm_t : filter_base_t
 		}
 	}
 
-	virtual bool is_none() const
+	[[nodiscard]] bool is_none() const override
 	{
 		return ranges.empty();
 	}
 
-	virtual std::string to_string() const
+	[[nodiscard]] std::string to_string() const override
 	{
 		std::string ret;
 
@@ -372,7 +370,7 @@ struct filter_prm_t : filter_base_t
 template<typename uint_t>
 ref_t<filter_prm_t<uint_t>> and_op(const ref_t<filter_prm_t<uint_t>>& a, const ref_t<filter_prm_t<uint_t>>& b)
 {
-	filter_prm_t<uint_t>* result = new filter_prm_t<uint_t>;
+	auto* result = new filter_prm_t<uint_t>;
 
 	for (const auto& a_item : a.filter->ranges)
 	{
@@ -397,7 +395,7 @@ using filter_prm16_t = filter_prm_t<uint16_t>;
 
 static inline ref_t<filter_prm16_t> icmp_prm1(const common::ranges_t& types, const common::ranges_t& codes)
 {
-	filter_prm16_t* filter = new filter_prm16_t;
+	auto* filter = new filter_prm16_t;
 
 	if (types == ranges_t{common::range_t{0x00, 0xFF}} && codes == ranges_t{common::range_t{0x00, 0xFF}})
 	{
@@ -594,12 +592,12 @@ struct filter_id_t : filter_base_t
 	inline filter_id_t(int _val) :
 	        val(_val) {}
 
-	virtual bool is_none() const
+	[[nodiscard]] bool is_none() const override
 	{
 		return val < 0;
 	}
 
-	virtual std::string to_string() const
+	[[nodiscard]] std::string to_string() const override
 	{
 		return std::to_string(val);
 	}
@@ -743,12 +741,12 @@ struct filter_proto_t : filter_base_t
 		}
 	}
 
-	virtual bool is_none() const
+	[[nodiscard]] bool is_none() const override
 	{
 		return type.is_none() || prm1.is_none() || prm2.is_none();
 	}
 
-	virtual std::string to_string() const
+	[[nodiscard]] std::string to_string() const override
 	{
 		bool has_ports = false, has_icmptypes = false,
 		     has_icmp6types = false, has_flags = false;
@@ -925,12 +923,12 @@ struct filter_t : filter_base_t
 		}
 	}
 
-	virtual bool is_none() const
+	[[nodiscard]] bool is_none() const override
 	{
 		return acl_id.is_none() || src.is_none() || dst.is_none() || proto.is_none() || dir.is_none() || recordstate.is_none();
 	}
 
-	virtual std::string to_string() const
+	[[nodiscard]] std::string to_string() const override
 	{
 		std::string ret;
 
@@ -1063,9 +1061,9 @@ struct rule_t
 	        log(false)
 	{}
 
-	rule_t(ipfw::rule_ptr_t rulep, ipfw::fw_config_ptr_t configp)
+	rule_t(ipfw::rule_ptr_t rulep, ipfw::fw_config_ptr_t configp) :
+	        text(rulep->text)
 	{
-		text = rulep->text;
 		switch (rulep->action)
 		{
 			case ipfw::rule_action_t::SKIPTO:
@@ -1116,12 +1114,12 @@ struct rule_t
 		ids.emplace_back(rulep->ruleid);
 		for (const auto& [name, how] : rulep->ifaces)
 		{
-			(void)how; // XXX: we can use in/out filters
+			YANET_GCC_BUG_UNUSED(how); // XXX: we can use in/out filters
 			via.insert(name);
 		}
 		for (const auto& [direction, tables] : rulep->iface_tables)
 		{
-			(void)direction; // XXX: we can use in/out filters
+			YANET_GCC_BUG_UNUSED(direction); // XXX: we can use in/out filters
 			for (const auto& tablename : tables)
 			{
 				if (configp->m_tables.count(tablename) == 0)
@@ -1135,7 +1133,7 @@ struct rule_t
 					const auto& ifnames = std::get<ipfw::tables::ifname_t>(table);
 					for (const auto& [iface, label] : ifnames)
 					{
-						(void)label;
+						YANET_GCC_BUG_UNUSED(label);
 						via.insert(iface);
 					}
 				}
@@ -1143,7 +1141,7 @@ struct rule_t
 				{
 					YANET_LOG_WARNING("wrong type for interface table %s\n", tablename.data());
 				}
-				(void)location;
+				YANET_GCC_BUG_UNUSED(location);
 			}
 		}
 	}
diff --git a/controlplane/acl_base.h b/controlplane/acl_base.h
index 49931b13..b5446c36 100644
--- a/controlplane/acl_base.h
+++ b/controlplane/acl_base.h
@@ -1,10 +1,6 @@
 #pragma once
 
-#include <map>
-#include <set>
-#include <unordered_map>
-
-#include <cinttypes>
+#include <cstdint>
 
 using tAclGroupId = uint32_t;
 
diff --git a/controlplane/acl_compiler.cpp b/controlplane/acl_compiler.cpp
index a3d07aa9..24ad9551 100644
--- a/controlplane/acl_compiler.cpp
+++ b/controlplane/acl_compiler.cpp
@@ -172,8 +172,8 @@ void compiler_t::collect(const std::vector<rule_t>& unwind_rules)
 			}
 			else
 			{
-				network_ipv4_source_filter.emplace(network_t(4, 0, 0));
-				network_ipv6_source_filter.emplace(network_t(6, 0, 0));
+				network_ipv4_source_filter.emplace(4, 0, 0);
+				network_ipv6_source_filter.emplace(6, 0, 0);
 
 				src_family[4] = true;
 				src_family[6] = true;
@@ -198,8 +198,8 @@ void compiler_t::collect(const std::vector<rule_t>& unwind_rules)
 			}
 			else
 			{
-				network_ipv4_destination_filter.emplace(network_t(4, 0, 0));
-				network_ipv6_destination_filter.emplace(network_t(6, 0, 0));
+				network_ipv4_destination_filter.emplace(4, 0, 0);
+				network_ipv6_destination_filter.emplace(6, 0, 0);
 
 				dst_family[4] = true;
 				dst_family[6] = true;
diff --git a/controlplane/acl_filter.h b/controlplane/acl_filter.h
index 5352ac1b..07a34d33 100644
--- a/controlplane/acl_filter.h
+++ b/controlplane/acl_filter.h
@@ -34,7 +34,7 @@ class filter_transport
 		                second.icmpv6_identifier);
 	}
 
-	inline bool protocol_contain(const uint8_t protocol_value) const
+	[[nodiscard]] inline bool protocol_contain(const uint8_t protocol_value) const
 	{
 		for (const auto& range : protocol.vector)
 		{
diff --git a/controlplane/acl_flat.h b/controlplane/acl_flat.h
index 9601bac3..de7e0bb8 100644
--- a/controlplane/acl_flat.h
+++ b/controlplane/acl_flat.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "acl/bitset.h"
 #include "acl_base.h"
 
 #include "common/acl.h"
diff --git a/controlplane/acl_network.h b/controlplane/acl_network.h
index 3171a253..ca5d2799 100644
--- a/controlplane/acl_network.h
+++ b/controlplane/acl_network.h
@@ -63,14 +63,12 @@ class network_t
 
 	void compile()
 	{
-		for (unsigned int filter_id = 0;
-		     filter_id < filters.size();
-		     filter_id++)
+		for (auto& filter : filters)
 		{
 			remap_group_ids.resize(0);
 			remap_group_ids.resize(group_id, 0);
 
-			for (const auto& network : filters[filter_id])
+			for (const auto& network : filter)
 			{
 				tree.insert(network.addr, network.mask, group_id, remap_group_ids);
 			}
diff --git a/controlplane/acl_network_table.cpp b/controlplane/acl_network_table.cpp
index 89b2da4c..c682c8e3 100644
--- a/controlplane/acl_network_table.cpp
+++ b/controlplane/acl_network_table.cpp
@@ -61,18 +61,11 @@ void network_table_t::prepare(const uint32_t height, const uint32_t width)
 
 void network_table_t::compile()
 {
-	for (unsigned int filter_id = 0;
-	     filter_id < filters.size();
-	     filter_id++)
+	for (auto [network_ipv4_source_filter_id, network_ipv4_destination_filter_id, network_ipv6_source_filter_id, network_ipv6_destination_filter_id] : filters)
 	{
 		remap_group_ids.clear();
 		remap_group_ids.resize(group_id, 0);
 
-		const auto& [network_ipv4_source_filter_id,
-		             network_ipv4_destination_filter_id,
-		             network_ipv6_source_filter_id,
-		             network_ipv6_destination_filter_id] = filters[filter_id];
-
 		const auto& network_ipv4_source_group_ids = compiler->network_ipv4_source.filter_group_ids[network_ipv4_source_filter_id];
 		const auto& network_ipv4_destination_group_ids = compiler->network_ipv4_destination.filter_group_ids[network_ipv4_destination_filter_id];
 		const auto& network_ipv6_source_group_ids = compiler->network_ipv6_source.filter_group_ids[network_ipv6_source_filter_id];
diff --git a/controlplane/acl_network_table.h b/controlplane/acl_network_table.h
index ac8a6470..b1e33695 100644
--- a/controlplane/acl_network_table.h
+++ b/controlplane/acl_network_table.h
@@ -1,6 +1,10 @@
 #pragma once
 
-#include "acl/bitset.h"
+#include <map>
+#include <set>
+#include <tuple>
+#include <vector>
+
 #include "acl_base.h"
 
 namespace acl::compiler
diff --git a/controlplane/acl_table.h b/controlplane/acl_table.h
index 281b712d..aa0d26e4 100644
--- a/controlplane/acl_table.h
+++ b/controlplane/acl_table.h
@@ -1,11 +1,7 @@
 #pragma once
 
-#include <functional>
-
-#include "acl/bitset.h"
 #include "acl_base.h"
-
-#include "common/acl.h"
+#include "common/define.h"
 
 namespace acl::compiler
 {
diff --git a/controlplane/acl_transport.cpp b/controlplane/acl_transport.cpp
index 2eaa3edc..840b074b 100644
--- a/controlplane/acl_transport.cpp
+++ b/controlplane/acl_transport.cpp
@@ -1,5 +1,4 @@
 #include "acl_compiler.h"
-#include "acl_network_table.h"
 
 using namespace acl::compiler;
 
@@ -64,10 +63,10 @@ void transport_t::distribute()
 	for (const auto& [key, network_table_group_ids] : variation)
 	{
 		const auto& [size, filter_ids] = key;
-		(void)size;
+		YANET_GCC_BUG_UNUSED(size);
 
 		unsigned int best_layer_id = 0;
-		size_t best_filter_ids_count = (size_t)-1;
+		auto best_filter_ids_count = (size_t)-1;
 
 		for (unsigned int layer_id = 0;
 		     layer_id < compiler->transport_layers_size_max;
@@ -105,12 +104,8 @@ void transport_t::distribute()
 
 void transport_t::compile()
 {
-	for (unsigned int layer_id = 0;
-	     layer_id < layers.size();
-	     layer_id++)
+	for (auto& layer : layers)
 	{
-		auto& layer = layers[layer_id];
-
 		for (const auto filter_id : layer.filter_ids_set)
 		{
 			const auto& filter = filters[filter_id];
@@ -144,12 +139,8 @@ void transport_t::compile()
 		layer.icmp_identifier.prepare();
 	}
 
-	for (unsigned int layer_id = 0;
-	     layer_id < layers.size();
-	     layer_id++)
+	for (auto& layer : layers)
 	{
-		auto& layer = layers[layer_id];
-
 		layer.protocol.compile();
 		layer.tcp_source.compile();
 		layer.tcp_destination.compile();
@@ -163,12 +154,8 @@ void transport_t::compile()
 
 void transport_t::populate()
 {
-	for (unsigned int layer_id = 0;
-	     layer_id < layers.size();
-	     layer_id++)
+	for (auto& layer : layers)
 	{
-		auto& layer = layers[layer_id];
-
 		layer.protocol.populate();
 		layer.tcp_source.populate();
 		layer.tcp_destination.populate();
diff --git a/controlplane/acl_transport_table.cpp b/controlplane/acl_transport_table.cpp
index c127f693..6a6bb050 100644
--- a/controlplane/acl_transport_table.cpp
+++ b/controlplane/acl_transport_table.cpp
@@ -72,9 +72,8 @@ transport_table::thread_t::thread_t(transport_table_t* transport_table,
                                     const unsigned int threads_count) :
         transport_table(transport_table),
         thread_id(thread_id),
-        threads_count(threads_count)
+        threads_count(threads_count), group_id(1 + thread_id)
 {
-	group_id = 1 + thread_id;
 }
 
 void transport_table::thread_t::start()
@@ -159,14 +158,11 @@ void transport_table::thread_t::compile()
 	std::array<size_t, dimension> table_indexes;
 	table_indexes.fill(0);
 
-	for (unsigned int filter_id = 0;
-	     filter_id < transport_table->filters.size();
-	     filter_id++)
+	for (auto [network_table_filter_id, network_flags_filter_id, transport_filter_id] : transport_table->filters)
 	{
 		remap_group_ids.clear();
 		remap_group_ids.resize(group_id, 0);
 
-		const auto& [network_table_filter_id, network_flags_filter_id, transport_filter_id] = transport_table->filters[filter_id];
 		const auto& network_table_group_ids_orig = transport_table->compiler->network_table.filter_id_group_ids[network_table_filter_id];
 		const auto& network_flags_group_ids = transport_table->compiler->network_flags.filter_id_group_ids[network_flags_filter_id];
 
diff --git a/controlplane/acl_transport_table.h b/controlplane/acl_transport_table.h
index caebf658..1064ec88 100644
--- a/controlplane/acl_transport_table.h
+++ b/controlplane/acl_transport_table.h
@@ -2,11 +2,9 @@
 
 #include <thread>
 
-#include "acl/bitset.h"
 #include "acl_base.h"
 #include "acl_table.h"
 
-#include "common/acl.h"
 #include "common/idp.h"
 
 namespace acl::compiler
diff --git a/controlplane/acl_tree.h b/controlplane/acl_tree.h
index 8cb9a526..90c78b78 100644
--- a/controlplane/acl_tree.h
+++ b/controlplane/acl_tree.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cinttypes>
-
 #include "common/acl.h"
 
 namespace acl::compiler
@@ -167,7 +165,7 @@ class tree_t
 	{
 		for (const auto& [gap_size, address, mask] : prefixes)
 		{
-			(void)gap_size;
+			YANET_GCC_BUG_UNUSED(gap_size);
 
 			if (is_mask_gapped(mask))
 			{
@@ -178,7 +176,7 @@ class tree_t
 
 		for (const auto& [gap_size, address, mask] : prefixes)
 		{
-			(void)gap_size;
+			YANET_GCC_BUG_UNUSED(gap_size);
 
 			if (!is_mask_gapped(mask))
 			{
@@ -272,7 +270,7 @@ class tree_t
 		{
 			const auto& [warp_address, warp_mask] = map_key;
 			const auto& [shift, warp_chunk_id] = map_value;
-			(void)shift;
+			YANET_GCC_BUG_UNUSED(shift);
 
 			std::set<unsigned int> last_multirefs_chunk_ids;
 			get_last_gapped_chunks_step(warp_address, warp_mask, last_multirefs_chunk_ids, root_chunk_id);
@@ -514,7 +512,7 @@ class tree_t
 			{
 				const auto& [prev_address, prev_mask] = key;
 				const auto& [prev_shift, prev_warp_chunk_id] = value;
-				(void)prev_warp_chunk_id;
+				YANET_GCC_BUG_UNUSED(prev_warp_chunk_id);
 
 				type_t shared_shadow_mask = warp_shadow_mask & (prev_mask & (prev_mask + 1));
 
@@ -571,8 +569,8 @@ class tree_t
 			const auto& [warp_address, warp_mask] = map_key;
 			const auto& [shift, warp_chunk_id] = map_value;
 
-			(void)shift;
-			(void)warp_chunk_id;
+			YANET_GCC_BUG_UNUSED(shift);
+			YANET_GCC_BUG_UNUSED(warp_chunk_id);
 
 			type_t warp_shadow_mask = warp_mask & (warp_mask + 1);
 
diff --git a/controlplane/balancer.cpp b/controlplane/balancer.cpp
index f17855f4..4774ef76 100644
--- a/controlplane/balancer.cpp
+++ b/controlplane/balancer.cpp
@@ -159,14 +159,14 @@ void balancer_t::Real(
 	request.reserve(req->reals().size());
 	for (const auto& real : req->reals())
 	{
-		request.push_back({real.module(),
-		                   convert_to_ip_address(real.virtual_ip()),
-		                   real.proto() == common::icp_proto::NetProto::tcp ? IPPROTO_TCP : IPPROTO_UDP,
-		                   real.virtual_port_opt_case() == common::icp_proto::BalancerRealRequest_Real::VirtualPortOptCase::kVirtualPort ? std::make_optional(real.virtual_port()) : std::nullopt,
-		                   convert_to_ip_address(real.real_ip()),
-		                   real.real_port_opt_case() == common::icp_proto::BalancerRealRequest_Real::RealPortOptCase::kRealPort ? std::make_optional(real.real_port()) : std::nullopt,
-		                   real.enable(),
-		                   real.weight_opt_case() == common::icp_proto::BalancerRealRequest_Real::WeightOptCase::kWeight ? std::make_optional(real.weight()) : std::nullopt});
+		request.emplace_back(real.module(),
+		                     convert_to_ip_address(real.virtual_ip()),
+		                     real.proto() == common::icp_proto::NetProto::tcp ? IPPROTO_TCP : IPPROTO_UDP,
+		                     real.virtual_port_opt_case() == common::icp_proto::BalancerRealRequest_Real::VirtualPortOptCase::kVirtualPort ? std::make_optional(real.virtual_port()) : std::nullopt,
+		                     convert_to_ip_address(real.real_ip()),
+		                     real.real_port_opt_case() == common::icp_proto::BalancerRealRequest_Real::RealPortOptCase::kRealPort ? std::make_optional(real.real_port()) : std::nullopt,
+		                     real.enable(),
+		                     real.weight_opt_case() == common::icp_proto::BalancerRealRequest_Real::WeightOptCase::kWeight ? std::make_optional(real.weight()) : std::nullopt);
 	}
 
 	balancer_real(request);
@@ -241,21 +241,21 @@ void balancer_t::reload(const controlplane::base_t& base_prev,
 		                  ipv6_outer_source_network,
 		                  reals] : balancer.services)
 		{
-			(void)service_id;
-			(void)version;
-			(void)scheduler;
-			(void)scheduler_params;
-			(void)reals;
-			(void)flags;
-			(void)forwarding_method;
-			(void)ipv4_outer_source_network;
-			(void)ipv6_outer_source_network;
+			YANET_GCC_BUG_UNUSED(service_id);
+			YANET_GCC_BUG_UNUSED(version);
+			YANET_GCC_BUG_UNUSED(scheduler);
+			YANET_GCC_BUG_UNUSED(scheduler_params);
+			YANET_GCC_BUG_UNUSED(reals);
+			YANET_GCC_BUG_UNUSED(flags);
+			YANET_GCC_BUG_UNUSED(forwarding_method);
+			YANET_GCC_BUG_UNUSED(ipv4_outer_source_network);
+			YANET_GCC_BUG_UNUSED(ipv6_outer_source_network);
 
 			service_counters.remove({module_name, {virtual_ip, proto, virtual_port}});
 
 			for (const auto& [real_ip, real_port, real_weight] : reals)
 			{
-				(void)real_weight;
+				YANET_GCC_BUG_UNUSED(real_weight);
 
 				const std::tuple<std::string,
 				                 balancer::service_key_t,
@@ -286,14 +286,14 @@ void balancer_t::reload(const controlplane::base_t& base_prev,
 		                  ipv6_outer_source_network,
 		                  reals] : balancer.services)
 		{
-			(void)service_id;
-			(void)version;
-			(void)scheduler;
-			(void)scheduler_params;
-			(void)flags;
-			(void)forwarding_method;
-			(void)ipv4_outer_source_network;
-			(void)ipv6_outer_source_network;
+			YANET_GCC_BUG_UNUSED(service_id);
+			YANET_GCC_BUG_UNUSED(version);
+			YANET_GCC_BUG_UNUSED(scheduler);
+			YANET_GCC_BUG_UNUSED(scheduler_params);
+			YANET_GCC_BUG_UNUSED(flags);
+			YANET_GCC_BUG_UNUSED(forwarding_method);
+			YANET_GCC_BUG_UNUSED(ipv4_outer_source_network);
+			YANET_GCC_BUG_UNUSED(ipv6_outer_source_network);
 
 			service_counters.insert({module_name, {virtual_ip, proto, virtual_port}});
 
@@ -301,7 +301,7 @@ void balancer_t::reload(const controlplane::base_t& base_prev,
 
 			for (const auto& [real_ip, real_port, real_weight] : reals)
 			{
-				(void)real_weight;
+				YANET_GCC_BUG_UNUSED(real_weight);
 
 				const std::tuple<std::string,
 				                 balancer::service_key_t,
@@ -405,10 +405,10 @@ common::icp::balancer_summary::response balancer_t::balancer_summary() const
 
 	for (auto& [response_module_name, response_services, response_reals_enabled, response_reals, response_connections, response_next_module] : response)
 	{
-		(void)response_services;
-		(void)response_reals_enabled;
-		(void)response_reals;
-		(void)response_next_module;
+		YANET_GCC_BUG_UNUSED(response_services);
+		YANET_GCC_BUG_UNUSED(response_reals_enabled);
+		YANET_GCC_BUG_UNUSED(response_reals);
+		YANET_GCC_BUG_UNUSED(response_next_module);
 
 		auto it = name_id.find(response_module_name);
 		if (it == name_id.end())
@@ -421,15 +421,15 @@ common::icp::balancer_summary::response balancer_t::balancer_summary() const
 		response_connections = 0;
 		for (const auto& [socket_id, service_connections] : balancer_service_connections)
 		{
-			(void)socket_id;
+			YANET_GCC_BUG_UNUSED(socket_id);
 
 			uint32_t socket_connections = 0;
 			for (const auto& [key, value] : service_connections)
 			{
 				const auto& [balancer_id, virtual_ip, proto, virtual_port] = key;
-				(void)virtual_ip;
-				(void)proto;
-				(void)virtual_port;
+				YANET_GCC_BUG_UNUSED(virtual_ip);
+				YANET_GCC_BUG_UNUSED(proto);
+				YANET_GCC_BUG_UNUSED(virtual_port);
 
 				if (response_module_id == balancer_id)
 				{
@@ -462,7 +462,7 @@ common::icp::balancer_service::response balancer_t::balancer_service(const commo
 	for (auto& [module, balancer] : services)
 	{
 		const auto& [module_id, module_name] = module;
-		(void)module_id;
+		YANET_GCC_BUG_UNUSED(module_id);
 
 		if (filter_module &&
 		    module_name != *filter_module)
@@ -495,9 +495,9 @@ common::icp::balancer_service::response balancer_t::balancer_service(const commo
 			response[module][service_key].swap(service);
 
 			auto& [scheduler, version, connections, packets, bytes] = response[module][service_key];
-			(void)scheduler;
-			(void)version;
-			(void)connections; ///< @todo: DELETE
+			YANET_GCC_BUG_UNUSED(scheduler);
+			YANET_GCC_BUG_UNUSED(version);
+			YANET_GCC_BUG_UNUSED(connections); ///< @todo: DELETE
 
 			auto it = counters.find({module_name,
 			                         {virtual_ip, proto, virtual_port}});
@@ -527,7 +527,7 @@ common::icp::balancer_real_find::response balancer_t::balancer_real_find(const c
 	for (auto& [module, balancer] : reals)
 	{
 		const auto& [module_id, module_name] = module;
-		(void)module_id;
+		YANET_GCC_BUG_UNUSED(module_id);
 
 		if (filter_module &&
 		    module_name != *filter_module)
@@ -560,15 +560,15 @@ common::icp::balancer_real_find::response balancer_t::balancer_real_find(const c
 			response[module][service_key].swap(service);
 
 			auto& [scheduler, version, response_reals] = response[module][service_key];
-			(void)scheduler;
-			(void)version;
+			YANET_GCC_BUG_UNUSED(scheduler);
+			YANET_GCC_BUG_UNUSED(version);
 
 			std::vector<common::icp::balancer_real_find::real> filtered_reals;
 			for (auto& [real_ip, real_port, enabled, weight, connections, packets, bytes] : response_reals)
 			{
-				(void)connections; ///< @todo: DELETE
-				(void)packets;
-				(void)bytes;
+				YANET_GCC_BUG_UNUSED(connections); ///< @todo: DELETE
+				YANET_GCC_BUG_UNUSED(packets);
+				YANET_GCC_BUG_UNUSED(bytes);
 
 				if (filter_real_ip &&
 				    real_ip != *filter_real_ip)
@@ -668,11 +668,11 @@ void balancer_t::update_service(const balancer::generation_config_t& generation_
 		                  ipv6_outer_source_network,
 		                  reals] : balancer.services)
 		{
-			(void)flags;
-			(void)scheduler_params;
-			(void)forwarding_method;
-			(void)ipv4_outer_source_network;
-			(void)ipv6_outer_source_network;
+			YANET_GCC_BUG_UNUSED(flags);
+			YANET_GCC_BUG_UNUSED(scheduler_params);
+			YANET_GCC_BUG_UNUSED(forwarding_method);
+			YANET_GCC_BUG_UNUSED(ipv4_outer_source_network);
+			YANET_GCC_BUG_UNUSED(ipv6_outer_source_network);
 
 			if (service_id >= YANET_CONFIG_BALANCER_SERVICES_SIZE)
 			{
@@ -684,9 +684,9 @@ void balancer_t::update_service(const balancer::generation_config_t& generation_
 			auto& [service_scheduler, service_version, service_connections, service_packets, service_bytes] = generation_services.services[{balancer.balancer_id, module_name}][{virtual_ip, proto, virtual_port}];
 			service_scheduler = to_string(scheduler); ///< @todo: OPT
 			service_version = version;
-			(void)service_connections; ///< @todo: DELETE
-			(void)service_packets; ///< filled in request
-			(void)service_bytes; ///< filled in request
+			YANET_GCC_BUG_UNUSED(service_connections); ///< @todo: DELETE
+			YANET_GCC_BUG_UNUSED(service_packets); ///< filled in request
+			YANET_GCC_BUG_UNUSED(service_bytes); ///< filled in request
 
 			auto& [reals_service_scheduler, reals_version, service_reals] = generation_services.reals[{balancer.balancer_id, module_name}][{virtual_ip, proto, virtual_port}];
 			reals_service_scheduler = service_scheduler;
@@ -764,8 +764,8 @@ void balancer_t::compile(common::idp::updateGlobalBase::request& globalbase,
 		                  ipv6_outer_source_network,
 		                  reals] : balancer.services)
 		{
-			(void)scheduler_params;
-			(void)version;
+			YANET_GCC_BUG_UNUSED(scheduler_params);
+			YANET_GCC_BUG_UNUSED(version);
 
 			if (service_id >= YANET_CONFIG_BALANCER_SERVICES_SIZE)
 			{
@@ -776,7 +776,7 @@ void balancer_t::compile(common::idp::updateGlobalBase::request& globalbase,
 
 			for (const auto& [real_ip, real_port, weight] : reals)
 			{
-				(void)weight;
+				YANET_GCC_BUG_UNUSED(weight);
 
 				balancer::real_key_global_t key = {module_name, {virtual_ip, proto, virtual_port}, {real_ip, real_port}};
 
@@ -797,15 +797,12 @@ void balancer_t::compile(common::idp::updateGlobalBase::request& globalbase,
 					}
 				}
 
-				req_reals.emplace_back(common::idp::updateGlobalBase::update_balancer_services::real{
-				        real_unordered_id,
-				        real_ip,
-				        counter_id});
+				req_reals.emplace_back(real_unordered_id, real_ip, counter_id);
 				req_binding.emplace_back(real_unordered_id);
 			}
 
 			const auto counter_id = service_counters.get_id({module_name, {virtual_ip, proto, virtual_port}});
-			req_services.emplace_back(common::idp::updateGlobalBase::update_balancer_services::service{
+			req_services.emplace_back(
 			        service_id,
 			        flags,
 			        counter_id,
@@ -815,8 +812,7 @@ void balancer_t::compile(common::idp::updateGlobalBase::request& globalbase,
 			        (uint32_t)real_start,
 			        (uint32_t)(req_reals.size() - real_start),
 			        ipv4_outer_source_network,
-			        ipv6_outer_source_network,
-			});
+			        ipv6_outer_source_network);
 		}
 	}
 
@@ -849,13 +845,13 @@ void balancer_t::flush_reals(common::idp::updateGlobalBaseBalancer::request& bal
 		                  ipv6_outer_source_network,
 		                  reals] : balancer.services)
 		{
-			(void)flags;
-			(void)scheduler;
-			(void)scheduler_params;
-			(void)version;
-			(void)forwarding_method;
-			(void)ipv4_outer_source_network;
-			(void)ipv6_outer_source_network;
+			YANET_GCC_BUG_UNUSED(flags);
+			YANET_GCC_BUG_UNUSED(scheduler);
+			YANET_GCC_BUG_UNUSED(scheduler_params);
+			YANET_GCC_BUG_UNUSED(version);
+			YANET_GCC_BUG_UNUSED(forwarding_method);
+			YANET_GCC_BUG_UNUSED(ipv4_outer_source_network);
+			YANET_GCC_BUG_UNUSED(ipv6_outer_source_network);
 
 			if (service_id >= YANET_CONFIG_BALANCER_SERVICES_SIZE)
 			{
diff --git a/controlplane/balancer.h b/controlplane/balancer.h
index 926f6ac2..3bcba0cf 100644
--- a/controlplane/balancer.h
+++ b/controlplane/balancer.h
@@ -10,7 +10,6 @@
 #include "common/generation.h"
 #include "common/icp.h"
 #include "common/idataplane.h"
-#include "common/refarray.h"
 #include "libprotobuf/controlplane.pb.h"
 
 namespace balancer
@@ -37,17 +36,11 @@ using real_counter_key_t = real_key_global_t;
 class generation_config_t
 {
 public:
-	generation_config_t() :
-	        services_count(0),
-	        reals_count(0)
-	{
-	}
+	generation_config_t() = default;
 
-	void update(const controlplane::base_t& base_prev,
+	void update([[maybe_unused]] const controlplane::base_t& base_prev,
 	            const controlplane::base_t& base_next)
 	{
-		(void)base_prev;
-
 		for (const auto& [name, balancer] : base_next.balancers)
 		{
 			name_id[name] = balancer.balancer_id;
@@ -61,20 +54,17 @@ class generation_config_t
 public:
 	std::map<std::string, balancer_id_t> name_id;
 	std::map<std::string, controlplane::balancer::config_t> config_balancers;
-	uint64_t services_count;
-	uint64_t reals_count;
+	uint64_t services_count{};
+	uint64_t reals_count{};
 };
 
 class generation_services_t
 {
 public:
-	generation_services_t() :
-	        reals_enabled_count(0)
-	{
-	}
+	generation_services_t() = default;
 
 public:
-	uint64_t reals_enabled_count;
+	uint64_t reals_enabled_count{};
 	common::icp::balancer_summary::response summary;
 	common::icp::balancer_service::response services;
 	common::icp::balancer_real_find::response reals;
diff --git a/controlplane/base.h b/controlplane/base.h
index 6b06b13d..7f96a5e4 100644
--- a/controlplane/base.h
+++ b/controlplane/base.h
@@ -1,11 +1,11 @@
 #pragma once
 
-#include <array>
 #include <map>
+#include <utility>
 #include <vector>
 
 #include "common/controlplaneconfig.h"
-#include "common/idp.h"
+#include "common/memory_manager.h"
 #include "common/nat46clat.h"
 #include "common/type.h"
 #include "libfwparser/fw_parser.h"
@@ -21,20 +21,16 @@ namespace base
 class logical_port_t
 {
 public:
-	logical_port_t() :
-	        vlanId(0),
-	        promiscuousMode(0)
-	{
-	}
+	logical_port_t() = default;
 
 public:
 	tLogicalPortId logicalPortId;
 
 	std::string physicalPort;
 	tPortId physicalPortId;
-	uint16_t vlanId;
+	uint16_t vlanId{};
 	mac_address_t macAddress;
-	uint8_t promiscuousMode;
+	uint8_t promiscuousMode{};
 	std::string nextModule;
 	common::globalBase::tFlow flow;
 };
@@ -42,13 +38,9 @@ class logical_port_t
 class decap_t
 {
 public:
-	decap_t() :
-	        dscpMarkType(common::eDscpMarkType::never),
-	        dscp(0)
-	{
-	}
+	decap_t() = default;
 
-	std::set<ipv6_prefix_t> prefixes() const
+	[[nodiscard]] std::set<ipv6_prefix_t> prefixes() const
 	{
 		std::set<ipv6_prefix_t> prefixes;
 		for (const auto& prefix : ipv6DestinationPrefixes)
@@ -62,8 +54,8 @@ class decap_t
 	tDecapId decapId;
 
 	std::set<ipv6_prefix_with_announces_t> ipv6DestinationPrefixes;
-	common::eDscpMarkType dscpMarkType;
-	uint8_t dscp;
+	common::eDscpMarkType dscpMarkType{common::eDscpMarkType::never};
+	uint8_t dscp{};
 	uint8_t ipv6_enabled;
 	std::string nextModule;
 	common::globalBase::tFlow flow;
@@ -72,19 +64,13 @@ class decap_t
 class nat64stateless_t
 {
 public:
-	nat64stateless_t() :
-	        dscpMarkType(common::eDscpMarkType::never),
-	        dscp(0),
-	        firewall(1),
-	        farm(0)
-	{
-	}
+	nat64stateless_t() = default;
 
 public:
 	tNat64statelessId nat64statelessId;
 
-	common::eDscpMarkType dscpMarkType;
-	uint8_t dscp;
+	common::eDscpMarkType dscpMarkType{common::eDscpMarkType::never};
+	uint8_t dscp{};
 
 	std::map<std::tuple<ipv6_address_t, ///< ipv6Address
 	                    ipv6_address_t, ///< ipv6DestinationAddress
@@ -94,7 +80,7 @@ class nat64stateless_t
 	                    tNat64statelessTranslationId>>
 	        translations;
 
-	uint8_t firewall;
+	uint8_t firewall{1};
 	std::optional<ipv6_prefix_t> nat64_wkp_prefix;
 	std::optional<ipv6_prefix_t> nat64_src_prefix;
 
@@ -105,7 +91,7 @@ class nat64stateless_t
 
 	std::optional<ipv6_address_t> defrag_farm_prefix;
 	std::optional<ipv6_address_t> defrag_source_prefix;
-	uint8_t farm;
+	uint8_t farm{};
 
 	/// @todo: ingressFlow;
 	/// @todo: egressFlow;
@@ -114,9 +100,7 @@ class nat64stateless_t
 class acl_rule_network_ipv4_t
 {
 public:
-	acl_rule_network_ipv4_t()
-	{
-	}
+	acl_rule_network_ipv4_t() = default;
 
 	acl_rule_network_ipv4_t(const std::set<ipv4_prefix_t>& sourcePrefixes,
 	                        const std::set<ipv4_prefix_t>& destinationPrefixes) :
@@ -133,9 +117,7 @@ class acl_rule_network_ipv4_t
 class acl_rule_network_ipv6_t
 {
 public:
-	acl_rule_network_ipv6_t()
-	{
-	}
+	acl_rule_network_ipv6_t() = default;
 
 	acl_rule_network_ipv6_t(const std::set<ipv6_prefix_t>& sourcePrefixes,
 	                        const std::set<ipv6_prefix_t>& destinationPrefixes) :
@@ -152,14 +134,12 @@ class acl_rule_network_ipv6_t
 class acl_rule_transport_tcp_t
 {
 public:
-	acl_rule_transport_tcp_t()
-	{
-	}
+	acl_rule_transport_tcp_t() = default;
 
-	acl_rule_transport_tcp_t(const ranges_t& sourcePorts,
-	                         const ranges_t& destinationPorts) :
-	        sourcePorts(sourcePorts),
-	        destinationPorts(destinationPorts)
+	acl_rule_transport_tcp_t(ranges_t sourcePorts,
+	                         ranges_t destinationPorts) :
+	        sourcePorts(std::move(sourcePorts)),
+	        destinationPorts(std::move(destinationPorts))
 	{
 	}
 
@@ -172,14 +152,12 @@ class acl_rule_transport_tcp_t
 class acl_rule_transport_udp_t
 {
 public:
-	acl_rule_transport_udp_t()
-	{
-	}
+	acl_rule_transport_udp_t() = default;
 
-	acl_rule_transport_udp_t(const ranges_t& sourcePorts,
-	                         const ranges_t& destinationPorts) :
-	        sourcePorts(sourcePorts),
-	        destinationPorts(destinationPorts)
+	acl_rule_transport_udp_t(ranges_t sourcePorts,
+	                         ranges_t destinationPorts) :
+	        sourcePorts(std::move(sourcePorts)),
+	        destinationPorts(std::move(destinationPorts))
 	{
 	}
 
@@ -198,27 +176,27 @@ class acl_rule_transport_icmpv4_t
 	{
 	}
 
-	acl_rule_transport_icmpv4_t(const ranges_t& types) :
-	        types(types),
+	acl_rule_transport_icmpv4_t(ranges_t types) :
+	        types(std::move(types)),
 	        codes(range_t{0x00, 0xFF}),
 	        identifiers(range_t{0x0000, 0xFFFF})
 	{
 	}
 
-	acl_rule_transport_icmpv4_t(const ranges_t& types,
-	                            const ranges_t& codes) :
-	        types(types),
-	        codes(codes),
+	acl_rule_transport_icmpv4_t(ranges_t types,
+	                            ranges_t codes) :
+	        types(std::move(types)),
+	        codes(std::move(codes)),
 	        identifiers(range_t{0x0000, 0xFFFF})
 	{
 	}
 
-	acl_rule_transport_icmpv4_t(const ranges_t& types,
-	                            const ranges_t& codes,
-	                            const ranges_t& identifiers) :
-	        types(types),
-	        codes(codes),
-	        identifiers(identifiers)
+	acl_rule_transport_icmpv4_t(ranges_t types,
+	                            ranges_t codes,
+	                            ranges_t identifiers) :
+	        types(std::move(types)),
+	        codes(std::move(codes)),
+	        identifiers(std::move(identifiers))
 	{
 	}
 
@@ -238,27 +216,27 @@ class acl_rule_transport_icmpv6_t
 	{
 	}
 
-	acl_rule_transport_icmpv6_t(const ranges_t& types) :
-	        types(types),
+	acl_rule_transport_icmpv6_t(ranges_t types) :
+	        types(std::move(types)),
 	        codes(range_t{0x00, 0xFF}),
 	        identifiers(range_t{0x0000, 0xFFFF})
 	{
 	}
 
-	acl_rule_transport_icmpv6_t(const ranges_t& types,
-	                            const ranges_t& codes) :
-	        types(types),
-	        codes(codes),
+	acl_rule_transport_icmpv6_t(ranges_t types,
+	                            ranges_t codes) :
+	        types(std::move(types)),
+	        codes(std::move(codes)),
 	        identifiers(range_t{0x0000, 0xFFFF})
 	{
 	}
 
-	acl_rule_transport_icmpv6_t(const ranges_t& types,
-	                            const ranges_t& codes,
-	                            const ranges_t& identifiers) :
-	        types(types),
-	        codes(codes),
-	        identifiers(identifiers)
+	acl_rule_transport_icmpv6_t(ranges_t types,
+	                            ranges_t codes,
+	                            ranges_t identifiers) :
+	        types(std::move(types)),
+	        codes(std::move(codes)),
+	        identifiers(std::move(identifiers))
 	{
 	}
 
@@ -271,12 +249,10 @@ class acl_rule_transport_icmpv6_t
 class acl_rule_transport_other_t
 {
 public:
-	acl_rule_transport_other_t()
-	{
-	}
+	acl_rule_transport_other_t() = default;
 
-	acl_rule_transport_other_t(const ranges_t& protocolTypes) :
-	        protocolTypes(protocolTypes)
+	acl_rule_transport_other_t(ranges_t protocolTypes) :
+	        protocolTypes(std::move(protocolTypes))
 	{
 	}
 
@@ -295,9 +271,7 @@ class acl_rule_t
 	};
 
 public:
-	acl_rule_t()
-	{
-	}
+	acl_rule_t() = default;
 
 	template<typename transport_T>
 	acl_rule_t(const std::variant<acl_rule_network_ipv4_t, acl_rule_network_ipv6_t>& network,
@@ -395,9 +369,7 @@ class acl_sync_config_t
 class acl_t
 {
 public:
-	acl_t()
-	{
-	}
+	acl_t() = default;
 
 public:
 	tAclId aclId;
@@ -430,26 +402,18 @@ class base_rib
 class base_t
 {
 public:
-	base_t() :
-	        interfacesCount(0),
-	        nat64statelessTranslationsCount(0),
-	        services_count(0),
-	        reals_count(0),
-	        tun64MappingsCount(0),
-	        storeSamples(false),
-	        serial(0),
-	        nat64stateful_pool_size(0)
+	base_t()
 	{
 		variables["balancer_real_timeout"] = 900;
 	}
 
 public:
 	std::map<std::string, std::string> moduleTypes;
-	tInterfaceId interfacesCount;
-	tNat64statelessTranslationId nat64statelessTranslationsCount;
-	balancer_service_id_t services_count;
-	balancer_real_id_t reals_count;
-	tun64_id_t tun64MappingsCount;
+	tInterfaceId interfacesCount{};
+	tNat64statelessTranslationId nat64statelessTranslationsCount{};
+	balancer_service_id_t services_count{};
+	balancer_real_id_t reals_count{};
+	tun64_id_t tun64MappingsCount{};
 	std::map<tInterfaceId, std::string> interfaceNames; ///< @todo: per route
 	std::map<tSocketId, std::set<tInterfaceId>> socket_interfaces; ///< @todo: per route
 
@@ -470,8 +434,8 @@ class base_t
 	acl::iface_map_t result_iface_map;
 	std::vector<std::string> dump_id_to_tag;
 	std::map<unsigned int, std::string> logicalport_id_to_name;
-	bool storeSamples;
-	uint32_t serial;
+	bool storeSamples{};
+	uint32_t serial{};
 
 	std::map<std::string, common::uint64> variables;
 	std::map<std::string, ///< vrf
@@ -479,7 +443,7 @@ class base_t
 	                  std::vector<std::string>>>
 	        vrf_fqdns;
 
-	uint32_t nat64stateful_pool_size;
+	uint32_t nat64stateful_pool_size{};
 
 	std::map<std::string, ///< vrf_name
 	         std::vector<base_rib>>
diff --git a/controlplane/bus.cpp b/controlplane/bus.cpp
index 0cd8d2ad..8584b4c5 100644
--- a/controlplane/bus.cpp
+++ b/controlplane/bus.cpp
@@ -103,7 +103,7 @@ void bus::clientThread(int clientSocket)
 
 	for (;;)
 	{
-		uint64_t messageSize;
+		uint64_t messageSize = 0;
 		if (auto err = common::recvAll(clientSocket, (char*)&messageSize, sizeof(messageSize)); err != 0)
 		{
 			/// @todo: log
diff --git a/controlplane/bus.h b/controlplane/bus.h
index e9c51494..3f4f7aed 100644
--- a/controlplane/bus.h
+++ b/controlplane/bus.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include "common/icp.h"
-
 #include "module.h"
 
 namespace controlplane::module
diff --git a/controlplane/configconverter.cpp b/controlplane/configconverter.cpp
index 4d32fe61..7062dcdb 100644
--- a/controlplane/configconverter.cpp
+++ b/controlplane/configconverter.cpp
@@ -7,9 +7,7 @@
 
 #include "acl.h"
 #include "configconverter.h"
-#include "controlplane.h"
 #include "errors.h"
-#include "isystem.h"
 
 eResult config_converter_t::process(uint32_t serial)
 {
@@ -339,7 +337,7 @@ void config_converter_t::processLogicalPorts()
 {
 	for (auto& [moduleName, logicalPort] : baseNext.logicalPorts)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		if (logicalPort.logicalPortId >= CONFIG_YADECAP_LOGICALPORTS_SIZE)
 		{
@@ -367,7 +365,7 @@ void config_converter_t::serializeLogicalPorts()
 {
 	for (auto& [moduleName, logicalPort] : baseNext.logicalPorts)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		globalbase.emplace_back(common::idp::updateGlobalBase::requestType::updateLogicalPort,
 		                        common::idp::updateGlobalBase::updateLogicalPort::request{logicalPort.logicalPortId,
@@ -383,7 +381,7 @@ void config_converter_t::processRoutes()
 {
 	for (auto& [module_name, route] : baseNext.routes)
 	{
-		(void)module_name;
+		YANET_GCC_BUG_UNUSED(module_name);
 
 		if (route.routeId >= CONFIG_YADECAP_ROUTES_SIZE)
 		{
@@ -392,7 +390,7 @@ void config_converter_t::processRoutes()
 
 		for (auto& [interface_name, interface] : route.interfaces)
 		{
-			(void)interface_name;
+			YANET_GCC_BUG_UNUSED(interface_name);
 
 			if (interface.interfaceId >= CONFIG_YADECAP_INTERFACES_SIZE)
 			{
@@ -427,7 +425,7 @@ void config_converter_t::serializeRoutes()
 {
 	for (auto& [moduleName, route] : baseNext.routes)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		std::optional<common::idp::updateGlobalBase::update_route::tunnel> tunnel;
 		if (route.tunnel_enabled)
@@ -449,7 +447,7 @@ void config_converter_t::processDecap()
 {
 	for (auto& [moduleName, decap] : baseNext.decaps)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		if (decap.decapId >= CONFIG_YADECAP_DECAPS_SIZE)
 		{
@@ -479,7 +477,7 @@ void config_converter_t::processNat64stateful()
 {
 	for (auto& [name, nat64stateful] : baseNext.nat64statefuls)
 	{
-		(void)name;
+		YANET_GCC_BUG_UNUSED(name);
 
 		if (nat64stateful.nat64stateful_id >= YANET_CONFIG_NAT64STATEFULS_SIZE)
 		{
@@ -504,7 +502,7 @@ void config_converter_t::processTun64()
 {
 	for (auto& [moduleName, tunnel] : baseNext.tunnels)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		if (tunnel.tun64Id >= CONFIG_YADECAP_TUN64_SIZE)
 		{
@@ -528,7 +526,7 @@ void config_converter_t::processNat64()
 {
 	for (auto& [moduleName, nat64stateless] : baseNext.nat64statelesses)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		if (nat64stateless.nat64statelessId >= CONFIG_YADECAP_NAT64STATELESSES_SIZE)
 		{
@@ -587,7 +585,7 @@ void config_converter_t::processNat46clat()
 {
 	for (auto& [module_name, nat46clat] : baseNext.nat46clats)
 	{
-		(void)module_name;
+		YANET_GCC_BUG_UNUSED(module_name);
 
 		if (nat46clat.nat46clat_id >= YANET_CONFIG_NAT46CLATS_SIZE)
 		{
@@ -614,7 +612,7 @@ void config_converter_t::processBalancer()
 
 	for (auto& [moduleName, balancer] : baseNext.balancers)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		if (balancer.balancer_id >= YANET_CONFIG_BALANCERS_SIZE)
 		{
@@ -650,17 +648,17 @@ void config_converter_t::processBalancer()
 		                  reals] : balancer.services)
 		{
 			/// @todo:
-			(void)vip;
-			(void)proto;
-			(void)vport;
-			(void)scheduler;
-			(void)scheduler_params;
-			(void)flags;
-			(void)reals;
-			(void)version;
-			(void)forwarding_method;
-			(void)ipv4_outer_source_network;
-			(void)ipv6_outer_source_network;
+			YANET_GCC_BUG_UNUSED(vip);
+			YANET_GCC_BUG_UNUSED(proto);
+			YANET_GCC_BUG_UNUSED(vport);
+			YANET_GCC_BUG_UNUSED(scheduler);
+			YANET_GCC_BUG_UNUSED(scheduler_params);
+			YANET_GCC_BUG_UNUSED(flags);
+			YANET_GCC_BUG_UNUSED(reals);
+			YANET_GCC_BUG_UNUSED(version);
+			YANET_GCC_BUG_UNUSED(forwarding_method);
+			YANET_GCC_BUG_UNUSED(ipv4_outer_source_network);
+			YANET_GCC_BUG_UNUSED(ipv6_outer_source_network);
 
 			if (service_id >= YANET_CONFIG_BALANCER_SERVICES_SIZE)
 			{
@@ -688,7 +686,7 @@ void config_converter_t::processDregress()
 {
 	for (auto& [moduleName, dregress] : baseNext.dregresses)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		if (dregress.dregressId >= CONFIG_YADECAP_DREGRESS_SIZE)
 		{
@@ -719,7 +717,7 @@ void config_converter_t::processAcl()
 {
 	for (auto& [moduleName, acl] : baseNext.acls)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		if (acl.synchronization)
 		{
@@ -872,7 +870,7 @@ void config_converter_t::acl_rules_route_local(controlplane::base::acl_t& acl,
 
 	for (const auto& [interfaceName, interface] : route.interfaces)
 	{
-		(void)interfaceName;
+		YANET_GCC_BUG_UNUSED(interfaceName);
 
 		for (const auto& ipAddress : interface.ip_prefixes)
 		{
@@ -892,10 +890,8 @@ void config_converter_t::acl_rules_route_local(controlplane::base::acl_t& acl,
 }
 
 void config_converter_t::acl_rules_route_forward(controlplane::base::acl_t& acl,
-                                                 const std::string& next_module) const
+                                                 [[maybe_unused]] const std::string& next_module) const
 {
-	(void)next_module;
-
 	common::globalBase::tFlow flow = convertToFlow(next_module);
 	acl.nextModuleRules.emplace_back(flow);
 }
@@ -1113,8 +1109,8 @@ void config_converter_t::acl_rules_nat64stateless_ingress(controlplane::base::ac
 		const auto& [ipv6Address, ipv6DestinationAddress, ingressPortRange] = key;
 		const auto& [ipv4Address, egressPortRange, translationId] = value;
 
-		(void)ipv4Address;
-		(void)egressPortRange;
+		YANET_GCC_BUG_UNUSED(ipv4Address);
+		YANET_GCC_BUG_UNUSED(egressPortRange);
 
 		flow.data.nat64stateless.translationId = translationId;
 		flow_icmp.data.nat64stateless.translationId = translationId;
@@ -1274,7 +1270,7 @@ void config_converter_t::acl_rules_nat64stateless_egress(controlplane::base::acl
 
 	for (const auto& [key, value] : nat64stateless.translations)
 	{
-		(void)key;
+		YANET_GCC_BUG_UNUSED(key);
 
 		const auto& [ipv4Address, egressPortRange, translationId] = value;
 
@@ -1609,13 +1605,13 @@ void config_converter_t::acl_rules_balancer(controlplane::base::acl_t& acl,
 	                  ipv6_outer_source_network,
 	                  reals] : balancer.services)
 	{
-		(void)scheduler;
-		(void)scheduler_params;
-		(void)version;
-		(void)flags;
-		(void)forwarding_method;
-		(void)ipv4_outer_source_network;
-		(void)ipv6_outer_source_network;
+		YANET_GCC_BUG_UNUSED(scheduler);
+		YANET_GCC_BUG_UNUSED(scheduler_params);
+		YANET_GCC_BUG_UNUSED(version);
+		YANET_GCC_BUG_UNUSED(flags);
+		YANET_GCC_BUG_UNUSED(forwarding_method);
+		YANET_GCC_BUG_UNUSED(ipv4_outer_source_network);
+		YANET_GCC_BUG_UNUSED(ipv6_outer_source_network);
 
 		if (reals.empty())
 		{
@@ -1703,15 +1699,15 @@ void config_converter_t::acl_rules_balancer_icmp_reply(controlplane::base::acl_t
 	                  ipv6_outer_source_network,
 	                  reals] : balancer.services)
 	{
-		(void)scheduler;
-		(void)scheduler_params;
-		(void)flags;
-		(void)proto;
-		(void)vport;
-		(void)version;
-		(void)forwarding_method;
-		(void)ipv4_outer_source_network;
-		(void)ipv6_outer_source_network;
+		YANET_GCC_BUG_UNUSED(scheduler);
+		YANET_GCC_BUG_UNUSED(scheduler_params);
+		YANET_GCC_BUG_UNUSED(flags);
+		YANET_GCC_BUG_UNUSED(proto);
+		YANET_GCC_BUG_UNUSED(vport);
+		YANET_GCC_BUG_UNUSED(version);
+		YANET_GCC_BUG_UNUSED(forwarding_method);
+		YANET_GCC_BUG_UNUSED(ipv4_outer_source_network);
+		YANET_GCC_BUG_UNUSED(ipv6_outer_source_network);
 
 		if (reals.empty())
 		{
@@ -1772,15 +1768,15 @@ void config_converter_t::acl_rules_balancer_icmp_forward(controlplane::base::acl
 	                  ipv6_outer_source_network,
 	                  reals] : balancer.services)
 	{
-		(void)scheduler;
-		(void)scheduler_params;
-		(void)flags;
-		(void)proto;
-		(void)vport;
-		(void)version;
-		(void)forwarding_method;
-		(void)ipv4_outer_source_network;
-		(void)ipv6_outer_source_network;
+		YANET_GCC_BUG_UNUSED(scheduler);
+		YANET_GCC_BUG_UNUSED(scheduler_params);
+		YANET_GCC_BUG_UNUSED(flags);
+		YANET_GCC_BUG_UNUSED(proto);
+		YANET_GCC_BUG_UNUSED(vport);
+		YANET_GCC_BUG_UNUSED(version);
+		YANET_GCC_BUG_UNUSED(forwarding_method);
+		YANET_GCC_BUG_UNUSED(ipv4_outer_source_network);
+		YANET_GCC_BUG_UNUSED(ipv6_outer_source_network);
 
 		if (reals.empty())
 		{
@@ -1812,8 +1808,8 @@ std::string config_converter_t::checkLimit(size_t count, const std::string& name
 	uint64_t limit = 0;
 	for (const auto& [limit_name, socket_id, current, maximum] : limits)
 	{
-		(void)socket_id;
-		(void)current;
+		YANET_GCC_BUG_UNUSED(socket_id);
+		YANET_GCC_BUG_UNUSED(current);
 
 		if (limit_name == name)
 		{
@@ -1859,10 +1855,10 @@ void config_converter_t::buildAcl()
 
 	for (auto& [route_name, route] : baseNext.routes)
 	{
-		(void)route_name;
+		YANET_GCC_BUG_UNUSED(route_name);
 		for (auto& [name, iface] : route.interfaces)
 		{
-			(void)name;
+			YANET_GCC_BUG_UNUSED(name);
 			auto it = result.out_iface_map.find(iface.nextModule);
 			if (it != result.out_iface_map.end())
 			{
@@ -1899,7 +1895,7 @@ void config_converter_t::buildAcl()
 	common::idp::updateGlobalBase::fwstate_synchronization_update::request fwstate_sync_request;
 	for (const auto& [moduleName, acl] : baseNext.acls)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		if (acl.synchronization)
 		{
@@ -1931,7 +1927,7 @@ void config_converter_t::buildAcl()
 	common::idp::updateGlobalBase::update_early_decap_flags::request early_decap_flags_request = false;
 	for (const auto& [moduleName, acl] : baseNext.acls)
 	{
-		(void)moduleName;
+		YANET_GCC_BUG_UNUSED(moduleName);
 
 		// if at least one acl module has early_decap config section, early_decap feature is globally switched on
 		if ((!acl.src4_early_decap.empty() && !acl.dst4_early_decap.empty()) || (!acl.src6_early_decap.empty() && !acl.dst6_early_decap.empty()))
diff --git a/controlplane/configconverter.h b/controlplane/configconverter.h
index 12c2da88..7b5751d9 100644
--- a/controlplane/configconverter.h
+++ b/controlplane/configconverter.h
@@ -1,22 +1,26 @@
 #pragma once
 
+#include <utility>
+
 #include "base.h"
+#include "common/idp.h"
+#include "common/result.h"
 
 class config_converter_t
 {
 public:
 	config_converter_t(cControlPlane* controlplane,
-	                   const controlplane::base_t& baseNext,
-	                   const common::idp::limits::response& limits) :
+	                   controlplane::base_t baseNext,
+	                   common::idp::limits::response limits) :
 	        controlplane(controlplane),
-	        baseNext(baseNext),
-	        limits(limits)
+	        baseNext(std::move(baseNext)),
+	        limits(std::move(limits))
 	{
 	}
 
 	[[nodiscard]] eResult process(uint32_t serial);
 
-	const controlplane::base_t& getBaseNext() const
+	[[nodiscard]] const controlplane::base_t& getBaseNext() const
 	{
 		return baseNext;
 	}
@@ -45,8 +49,8 @@ class config_converter_t
 	std::string checkLimit(size_t count, const std::string& limit, size_t multiplier(size_t));
 
 	void convertToFlow(const std::string& nextModule, common::globalBase::tFlow& flow) const;
-	common::globalBase::tFlow convertToFlow(std::string nextModule) const;
-	common::globalBase::tFlow convertToFlow(std::string nextModule, const std::string& entryName) const;
+	[[nodiscard]] common::globalBase::tFlow convertToFlow(std::string nextModule) const;
+	[[nodiscard]] common::globalBase::tFlow convertToFlow(std::string nextModule, const std::string& entryName) const;
 
 	void acl_rules_route_local(controlplane::base::acl_t& acl, const std::string& next_module) const;
 	void acl_rules_route_forward(controlplane::base::acl_t& acl, const std::string& next_module) const;
diff --git a/controlplane/configparser.cpp b/controlplane/configparser.cpp
index af331d5e..92054e4c 100644
--- a/controlplane/configparser.cpp
+++ b/controlplane/configparser.cpp
@@ -156,33 +156,33 @@ controlplane::base_t config_parser_t::loadConfig(const std::string& rootFilePath
 	try
 	{
 		const auto& [dataplane_physicalports, dataplane_workers, dataplane_values] = dataPlaneConfig;
-		(void)dataplane_workers;
-		(void)dataplane_values;
+		YANET_GCC_BUG_UNUSED(dataplane_workers);
+		YANET_GCC_BUG_UNUSED(dataplane_values);
 
 		for (const auto& [core_id, worker] : dataplane_workers)
 		{
-			(void)core_id;
+			YANET_GCC_BUG_UNUSED(core_id);
 			const auto& [ports, socket_id] = worker;
-			(void)ports;
+			YANET_GCC_BUG_UNUSED(ports);
 			// add entry for sockets with workers, including slow worker
 			baseNext.socket_interfaces[socket_id] = {};
 		}
 		for (const auto& [route_name, route] : baseNext.routes)
 		{
-			(void)route_name;
+			YANET_GCC_BUG_UNUSED(route_name);
 
 			for (const auto& [interface_name, interface] : route.interfaces)
 			{
-				(void)interface_name;
+				YANET_GCC_BUG_UNUSED(interface_name);
 
 				if (exist(baseNext.logicalPorts, interface.nextModule))
 				{
 					const auto& logicalport = baseNext.logicalPorts[interface.nextModule];
 
 					const auto& [physicalport_name, socket_id, mac_address, pci] = dataplane_physicalports.find(logicalport.physicalPortId)->second;
-					(void)physicalport_name;
-					(void)mac_address;
-					(void)pci;
+					YANET_GCC_BUG_UNUSED(physicalport_name);
+					YANET_GCC_BUG_UNUSED(mac_address);
+					YANET_GCC_BUG_UNUSED(pci);
 
 					baseNext.socket_interfaces[socket_id].emplace(interface.interfaceId);
 				}
@@ -501,12 +501,9 @@ void config_parser_t::loadConfig_decap(controlplane::base_t& baseNext,
 void config_parser_t::loadConfig_nat64stateful(controlplane::base_t& baseNext,
                                                const std::string& moduleId,
                                                const nlohmann::json& moduleJson,
-                                               const std::string& rootFilePath,
-                                               const std::map<std::string, nlohmann::json>& jsons)
+                                               [[maybe_unused]] const std::string& rootFilePath,
+                                               [[maybe_unused]] const std::map<std::string, nlohmann::json>& jsons)
 {
-	(void)rootFilePath;
-	(void)jsons;
-
 	auto& nat64stateful = baseNext.nat64statefuls[moduleId];
 	nat64stateful_id_t nat64stateful_id = baseNext.nat64statefuls.size();
 
@@ -634,7 +631,7 @@ void config_parser_t::loadConfig_tun64(controlplane::base_t& baseNext,
 	}
 	else
 	{
-		tunnel.prefixes.emplace(common::ip_prefix_t(tunnel.ipv6SourceAddress, 128));
+		tunnel.prefixes.emplace(tunnel.ipv6SourceAddress, 128);
 	}
 
 	if (exist(moduleJson, "mappings"))
@@ -1013,12 +1010,9 @@ void config_parser_t::loadConfig_nat64stateless_translations(controlplane::base_
 void config_parser_t::loadConfig_nat46clat(controlplane::base_t& baseNext,
                                            const std::string& moduleId,
                                            const nlohmann::json& moduleJson,
-                                           const std::string& rootFilePath,
-                                           const std::map<std::string, nlohmann::json>& jsons)
+                                           [[maybe_unused]] const std::string& rootFilePath,
+                                           [[maybe_unused]] const std::map<std::string, nlohmann::json>& jsons)
 {
-	(void)rootFilePath;
-	(void)jsons;
-
 	auto& nat46clat = baseNext.nat46clats[moduleId];
 	nat46clat_id_t nat46clat_id = baseNext.nat46clats.size();
 
@@ -1136,7 +1130,7 @@ void config_parser_t::loadConfig_acl(controlplane::base_t& baseNext,
 
 	if (exist(moduleJson, "macros"))
 	{
-		std::string includePath = moduleJson["macros"].get<std::string>();
+		auto includePath = moduleJson["macros"].get<std::string>();
 		if (includePath.find("/") != 0) ///< relative path
 		{
 			includePath = dirname(rootFilePath) + "/" + includePath;
@@ -1149,7 +1143,7 @@ void config_parser_t::loadConfig_acl(controlplane::base_t& baseNext,
 
 	if (exist(moduleJson, "dnscache"))
 	{
-		std::string includePath = moduleJson["dnscache"].get<std::string>();
+		auto includePath = moduleJson["dnscache"].get<std::string>();
 		if (includePath.find("/") != 0) ///< relative path
 		{
 			includePath = dirname(rootFilePath) + "/" + includePath;
@@ -1213,7 +1207,7 @@ void config_parser_t::loadConfig_acl(controlplane::base_t& baseNext,
 
 			for (const auto& ipJson : srcPrefixes)
 			{
-				std::string prefix_str = ipJson.get<std::string>();
+				auto prefix_str = ipJson.get<std::string>();
 				ip_prefix_t prefix(prefix_str);
 
 				if (prefix.is_ipv4())
@@ -1231,7 +1225,7 @@ void config_parser_t::loadConfig_acl(controlplane::base_t& baseNext,
 		{
 			for (const auto& ipJson : earlyDecapJson["dstAddresses"])
 			{
-				std::string addr_str = ipJson.get<std::string>();
+				auto addr_str = ipJson.get<std::string>();
 				ip_prefix_t addr(addr_str);
 
 				if (addr.is_ipv4())
@@ -1655,7 +1649,7 @@ void config_parser_t::loadConfig_balancer_services(controlplane::base_t& baseNex
 
 		std::string scheduler_string = service_json["scheduler"];
 
-		balancer::scheduler scheduler;
+		balancer::scheduler scheduler{};
 		balancer::scheduler_params scheduler_params{};
 		if (scheduler_string == "rr")
 		{
@@ -1678,7 +1672,7 @@ void config_parser_t::loadConfig_balancer_services(controlplane::base_t& baseNex
 			throw error_result_t(eResult::invalidConfigurationFile, "unknown scheduler: " + scheduler_string);
 		}
 
-		balancer::forwarding_method forwarding_method;
+		balancer::forwarding_method forwarding_method{};
 
 		if (!exist(service_json, "lvs_method"))
 		{
@@ -1919,7 +1913,7 @@ void config_parser_t::loadConfig_memory_group(common::memory_manager::memory_gro
 	{
 		auto memory_group_next = std::make_shared<common::memory_manager::memory_group>();
 
-		std::string name = json_iter["name"].get<std::string>();
+		auto name = json_iter["name"].get<std::string>();
 		std::string limit = "0";
 		if (exist(json_iter, "limit"))
 		{
diff --git a/controlplane/configparser.h b/controlplane/configparser.h
index ad8af05f..2b86dad8 100644
--- a/controlplane/configparser.h
+++ b/controlplane/configparser.h
@@ -5,18 +5,19 @@
 #include "common/controlplaneconfig.h"
 
 #include "base.h"
+#include "common/idp.h"
 
 class config_parser_t
 {
 public:
 	config_parser_t(common::idp::getConfig::response dataPlaneConfig) :
-	        dataPlaneConfig(dataPlaneConfig)
+	        dataPlaneConfig(std::move(dataPlaneConfig))
 	{}
 
 	controlplane::base_t loadConfig(const std::string& rootFilePath, const nlohmann::json& rootJson, const std::map<std::string, nlohmann::json>& jsons = {});
 
 protected:
-	tPortId getPhysicalPortId(const std::string& name) const;
+	[[nodiscard]] tPortId getPhysicalPortId(const std::string& name) const;
 	void loadConfig_logicalPort(controlplane::base_t& baseNext, const std::string& moduleId, const nlohmann::json& moduleJson);
 	void loadConfig_route(controlplane::base_t& baseNext, const std::string& moduleId, const nlohmann::json& moduleJson, const std::string& rootFilePath, const std::map<std::string, nlohmann::json>& jsons);
 	void loadConfig_route_peers(controlplane::base_t& baseNext, controlplane::route::config_t& route, const nlohmann::json& json, const std::string& rootFilePath, const std::map<std::string, nlohmann::json>& jsons);
diff --git a/controlplane/controlplane.cpp b/controlplane/controlplane.cpp
index b51b43f6..ae31b56d 100644
--- a/controlplane/controlplane.cpp
+++ b/controlplane/controlplane.cpp
@@ -21,10 +21,6 @@ cControlPlane::cControlPlane() :
 {
 }
 
-cControlPlane::~cControlPlane()
-{
-}
-
 eResult cControlPlane::init(const std::string& jsonFilePath)
 {
 	eResult result = eResult::success;
@@ -485,7 +481,7 @@ common::icp::acl_lookup::response cControlPlane::acl_lookup(const common::icp::a
 	std::map<uint32_t, std::string> labels;
 	for (const auto& [module, acl] : acls)
 	{
-		(void)module;
+		YANET_GCC_BUG_UNUSED(module);
 
 		for (const auto& [label, info] : acl.firewall->labels())
 		{
@@ -507,7 +503,7 @@ common::icp::acl_lookup::response cControlPlane::acl_lookup(const common::icp::a
 
 		for (const auto& [id, gen_text, orig_text] : rules)
 		{
-			(void)gen_text;
+			YANET_GCC_BUG_UNUSED(gen_text);
 
 			if (ids.count(id))
 			{
@@ -607,7 +603,7 @@ common::icp::getFwLabels::response cControlPlane::command_getFwLabels()
 	for (const auto& [module, acl] : current.acls)
 	{
 		const auto& fw = acl.firewall;
-		(void)module;
+		YANET_GCC_BUG_UNUSED(module);
 		for (const auto& [label, info] : fw->labels())
 		{
 			auto ruleno = std::get<unsigned int>(info);
@@ -657,7 +653,7 @@ common::icp::getFwList::response cControlPlane::command_getFwList(const common::
 
 		for (const auto& [id, gen_text, unused_text] : current.dispatcher)
 		{
-			(void)unused_text;
+			YANET_GCC_BUG_UNUSED(unused_text);
 			// XXX: if we need accounting for dispatcher rules
 			//      we can prepare id mappings for them.
 			response_rules.emplace_back(id, 0, gen_text);
@@ -849,7 +845,7 @@ common::icp::convert::response cControlPlane::convert_logical_module()
 
 	for (auto [id, name] : logicalport_id_to_name)
 	{
-		response.push_back({id, name});
+		response.emplace_back(id, name);
 	}
 
 	return response;
@@ -1008,7 +1004,7 @@ std::vector<uint64_t> cControlPlane::getAclCounters()
 	uint64_t start_acl_counters = sdp_data.metadata_worker.start_acl_counters;
 	for (const auto& iter : sdp_data.workers)
 	{
-		uint64_t* aclCounters = common::sdp::ShiftBuffer<uint64_t*>(iter.second.buffer, start_acl_counters);
+		auto* aclCounters = common::sdp::ShiftBuffer<uint64_t*>(iter.second.buffer, start_acl_counters);
 		for (size_t i = 0; i < YANET_CONFIG_ACL_COUNTERS_SIZE; i++)
 		{
 			response[i] += aclCounters[i];
diff --git a/controlplane/controlplane.h b/controlplane/controlplane.h
index 9ff14ab5..7f98d1a6 100644
--- a/controlplane/controlplane.h
+++ b/controlplane/controlplane.h
@@ -1,8 +1,5 @@
 #pragma once
 
-#include <atomic>
-#include <functional>
-#include <map>
 #include <mutex>
 #include <shared_mutex>
 #include <thread>
@@ -11,17 +8,12 @@
 
 #include <nlohmann/json.hpp>
 
+#include "balancer.h"
 #include "common/generation.h"
 #include "common/icp.h"
 #include "common/idataplane.h"
 #include "common/idp.h"
 #include "common/result.h"
-#include "common/sdpclient.h"
-#include "libprotobuf/controlplane.pb.h"
-
-#include "balancer.h"
-#include "base.h"
-#include "counter.h"
 #include "dregress.h"
 #include "durations.h"
 #include "fqdn.h"
@@ -38,7 +30,7 @@ class cControlPlane
 {
 public:
 	cControlPlane();
-	~cControlPlane();
+	~cControlPlane() = default;
 
 	eResult init(const std::string& jsonFilePath);
 	void start();
@@ -68,14 +60,14 @@ class cControlPlane
 		else if constexpr (std::is_invocable_r_v<common::icp::response, decltype(function)>)
 		{
 			commands[type] = [function](const common::icp::request& request) {
-				(void)request;
+				YANET_GCC_BUG_UNUSED(request);
 				return function();
 			};
 		}
 		else if constexpr (std::is_invocable_r_v<void, decltype(function)>)
 		{
 			commands[type] = [function](const common::icp::request& request) {
-				(void)request;
+				YANET_GCC_BUG_UNUSED(request);
 				function();
 				return std::tuple<>{};
 			};
diff --git a/controlplane/counter.h b/controlplane/counter.h
index c961ab99..c0a8acd6 100644
--- a/controlplane/counter.h
+++ b/controlplane/counter.h
@@ -1,15 +1,10 @@
 #pragma once
 
-#include <mutex>
-#include <set>
-
-#include "segment_allocator.h"
-#include "type.h"
-
 #include "common/icp.h"
-#include "common/idataplane.h"
-#include "common/refarray.h"
 #include "common/sdpclient.h"
+#include "common/sdpcommon.h"
+#include "segment_allocator.h"
+#include <mutex>
 
 class counter_manager_t
 {
@@ -126,10 +121,7 @@ class counter_t
 public:
 	static_assert(size_T <= YANET_CONFIG_COUNTER_FALLBACK_SIZE);
 
-	counter_t() :
-	        manager(nullptr)
-	{
-	}
+	counter_t() = default;
 
 	void init(counter_manager_t* manager)
 	{
@@ -160,7 +152,7 @@ class counter_t
 
 	void allocate()
 	{
-		allocate([](const key_T& key) { (void)key; });
+		allocate([]([[maybe_unused]] const key_T& key) {});
 	}
 
 	template<typename callback_T>
@@ -180,7 +172,7 @@ class counter_t
 
 	void release()
 	{
-		release([](const key_T& key) { (void)key; });
+		release([]([[maybe_unused]] const key_T& key) {});
 	}
 
 	void insert(const key_T& key)
@@ -191,7 +183,7 @@ class counter_t
 		if (counters_it != counters.end())
 		{
 			auto& [counter_id, refcount] = counters_it->second;
-			(void)counter_id;
+			YANET_GCC_BUG_UNUSED(counter_id);
 
 			if (!refcount)
 			{
@@ -273,7 +265,7 @@ class counter_t
 		}
 
 		const auto& [counter_id, refcount] = iter->second;
-		(void)refcount;
+		YANET_GCC_BUG_UNUSED(refcount);
 
 		return counter_id;
 	}
@@ -286,7 +278,7 @@ class counter_t
 		std::vector<tCounterId> manager_counter_ids;
 		for (const auto& [key, counter_id] : counters_allocated)
 		{
-			(void)key;
+			YANET_GCC_BUG_UNUSED(key);
 
 			for (size_t index = 0; index < size_T; index++)
 			{
@@ -301,7 +293,7 @@ class counter_t
 		size_t i = 0;
 		for (const auto& [key, counter_id] : counters_allocated)
 		{
-			(void)counter_id;
+			YANET_GCC_BUG_UNUSED(counter_id);
 
 			std::array<uint64_t, size_T> array;
 			for (size_t array_i = 0;
@@ -352,7 +344,7 @@ class counter_t
 	}
 
 protected:
-	counter_manager_t* manager;
+	counter_manager_t* manager{};
 
 	mutable std::mutex mutex;
 
diff --git a/controlplane/dregress.cpp b/controlplane/dregress.cpp
index c5a10764..21156075 100644
--- a/controlplane/dregress.cpp
+++ b/controlplane/dregress.cpp
@@ -48,12 +48,12 @@ void dregress_t::prefix_insert(const std::tuple<std::string, uint32_t>& vrf_prio
 
 	for (const auto& [pptn_index, path_info_to_nh_ptr] : nexthops)
 	{
-		(void)pptn_index;
+		YANET_GCC_BUG_UNUSED(pptn_index);
 
 		for (const auto& [path_info, nexthop_stuff_ptr] : path_info_to_nh_ptr)
 		{
 			const auto& [nexthop, labels, origin, med, aspath, nexthop_communities, large_communities, local_preference] = *nexthop_stuff_ptr;
-			(void)large_communities;
+			YANET_GCC_BUG_UNUSED(large_communities);
 
 			if ((prefix.is_ipv4() && nexthop.is_ipv4()) ||
 			    (prefix.is_ipv6() && nexthop.is_ipv6()))
@@ -232,7 +232,7 @@ void dregress_t::compile(common::idp::updateGlobalBase::request& globalbase,
 
 	for (const auto& [config_module_name, config_module] : generation.dregresses)
 	{
-		(void)config_module_name;
+		YANET_GCC_BUG_UNUSED(config_module_name);
 
 		globalbase.emplace_back(common::idp::updateGlobalBase::requestType::dregress_local_prefix_update,
 		                        config_module.localPrefixes);
@@ -297,11 +297,11 @@ void dregress_t::value_compile(common::idp::updateGlobalBase::request& globalbas
 	bool is_best = true;
 	for (const auto& [attribute, destinations] : attribute_destinations)
 	{
-		(void)attribute;
+		YANET_GCC_BUG_UNUSED(attribute);
 
 		for (const auto& [nexthop, label, communities, peer_as, origin_as] : destinations)
 		{
-			(void)vrf_priority; ///< @todo
+			YANET_GCC_BUG_UNUSED(vrf_priority); ///< @todo
 			auto community = generation.get_peer_link_community(communities);
 			if (community)
 			{
diff --git a/controlplane/dregress.h b/controlplane/dregress.h
index 3ea8cd41..a512b1b8 100644
--- a/controlplane/dregress.h
+++ b/controlplane/dregress.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "base.h"
+#include "isystem.h"
 #include "module.h"
 #include "rib.h"
 #include "type.h"
@@ -26,33 +27,29 @@ using value_key_t = std::tuple<std::tuple<std::string, ///< vrf
 class generation_t
 {
 public:
-	generation_t()
-	{
-	}
+	generation_t() = default;
 
-	void update(const controlplane::base_t& base_prev,
+	void update([[maybe_unused]] const controlplane::base_t& base_prev,
 	            const controlplane::base_t& base_next)
 	{
-		(void)base_prev;
-
 		routes = base_next.routes;
 		dregresses = base_next.dregresses;
 
 		/// @todo: VRF
 		for (const auto& [moduleName, dregress] : dregresses)
 		{
-			(void)moduleName;
+			YANET_GCC_BUG_UNUSED(moduleName);
 
 			our_as.insert(dregress.ourAs.begin(), dregress.ourAs.end());
 		}
 	}
 
-	std::optional<community_t> get_peer_link_community(const std::set<community_t>& communities) const
+	[[nodiscard]] std::optional<community_t> get_peer_link_community(const std::set<community_t>& communities) const
 	{
 		/// @todo: VRF
 		for (const auto& [moduleName, dregress] : dregresses)
 		{
-			(void)moduleName;
+			YANET_GCC_BUG_UNUSED(moduleName);
 
 			for (const auto& community : communities)
 			{
diff --git a/controlplane/durations.h b/controlplane/durations.h
index a9df8bf9..8b64d3f6 100644
--- a/controlplane/durations.h
+++ b/controlplane/durations.h
@@ -2,9 +2,7 @@
 
 #include <mutex>
 
-#include "base.h"
 #include "module.h"
-#include "type.h"
 
 class durations_t : public module_t
 {
diff --git a/controlplane/errors.h b/controlplane/errors.h
index 81f63891..468a3d3c 100644
--- a/controlplane/errors.h
+++ b/controlplane/errors.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <stdexcept>
 #include <string>
 
 #include "common/result.h"
@@ -11,7 +12,7 @@ class error_result_t : public std::runtime_error
 	        std::runtime_error(error), code(result)
 	{}
 
-	eResult result() const
+	[[nodiscard]] eResult result() const
 	{
 		return code;
 	}
diff --git a/controlplane/fqdn.cpp b/controlplane/fqdn.cpp
index 0852ca39..503d1ce4 100644
--- a/controlplane/fqdn.cpp
+++ b/controlplane/fqdn.cpp
@@ -21,10 +21,8 @@ void fqdn_t::reload_before()
 
 void fqdn_t::reload(const controlplane::base_t& base_prev,
                     const controlplane::base_t& base_next,
-                    common::idp::updateGlobalBase::request& globalbase)
+                    [[maybe_unused]] common::idp::updateGlobalBase::request& globalbase)
 {
-	(void)globalbase;
-
 	generations.next().update(base_prev, base_next);
 }
 
diff --git a/controlplane/fqdn.h b/controlplane/fqdn.h
index 373601a6..26ebf043 100644
--- a/controlplane/fqdn.h
+++ b/controlplane/fqdn.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "base.h"
-#include "counter.h"
 #include "module.h"
 #include "type.h"
 
@@ -18,7 +17,7 @@ class generation_t
 	void update(const controlplane::base_t& base_prev,
 	            const controlplane::base_t& base_next)
 	{
-		(void)base_prev;
+		YANET_GCC_BUG_UNUSED(base_prev);
 
 		vrf_fqdns = base_next.vrf_fqdns;
 
diff --git a/controlplane/isystem.cpp b/controlplane/isystem.cpp
index f95db2d0..b3182d7d 100644
--- a/controlplane/isystem.cpp
+++ b/controlplane/isystem.cpp
@@ -1,13 +1,12 @@
-#include <errno.h>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
 #include <ifaddrs.h>
 #include <linux/sockios.h>
 #include <net/if.h>
 #include <net/if_arp.h>
 #include <netdb.h>
 #include <netinet/in.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
 #include <unistd.h>
@@ -41,11 +40,11 @@ bool system::getEtherAddress(const uint32_t& ipAddress,
 {
 	/// @todo: try to connect
 
-	int arpSocket;
+	int arpSocket = 0;
 	struct arpreq request;
-	struct sockaddr_in* sin;
-	struct ifaddrs* interfaces;
-	struct ifaddrs* interfaceNext;
+	struct sockaddr_in* sin = nullptr;
+	struct ifaddrs* interfaces = nullptr;
+	struct ifaddrs* interfaceNext = nullptr;
 
 	arpSocket = socket(AF_INET, SOCK_DGRAM, 0);
 	if (arpSocket == -1)
@@ -179,8 +178,7 @@ void system::updateRoute(const uint32_t& network,
 		snprintf(buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), " nexthop via %s", ipv4_address_t(nexthop).toString().data());
 	}
 
-	int ret = ::system(buffer);
-	(void)ret;
+	[[maybe_unused]] int ret = ::system(buffer);
 }
 
 void system::updateRoute(const ip_prefix_t& prefix,
@@ -221,8 +219,7 @@ void system::removeRoute(const uint32_t& network,
 	char buffer[512];
 	snprintf(buffer, sizeof(buffer), "ip route del %s", prefix.toString().data());
 
-	int ret = ::system(buffer);
-	(void)ret;
+	[[maybe_unused]] int ret = ::system(buffer);
 }
 
 void system::removeRoute(const ip_prefix_t& prefix)
@@ -242,9 +239,9 @@ std::set<uint32_t> system::getLocalIpAddresses()
 {
 	std::set<uint32_t> result;
 
-	struct ifaddrs* ifaddr;
-	struct ifaddrs* ifa;
-	int n;
+	struct ifaddrs* ifaddr = nullptr;
+	struct ifaddrs* ifa = nullptr;
+	int n = 0;
 
 	if (getifaddrs(&ifaddr) == -1)
 	{
@@ -276,9 +273,9 @@ std::set<std::array<uint8_t, 16>> system::getLocalIPv6Addresses()
 {
 	std::set<std::array<uint8_t, 16>> result;
 
-	struct ifaddrs* ifaddr;
-	struct ifaddrs* ifa;
-	int n;
+	struct ifaddrs* ifaddr = nullptr;
+	struct ifaddrs* ifa = nullptr;
+	int n = 0;
 
 	if (getifaddrs(&ifaddr) == -1)
 	{
@@ -308,11 +305,9 @@ std::set<std::array<uint8_t, 16>> system::getLocalIPv6Addresses()
 	return result;
 }
 
-std::optional<mac_address_t> system::get_mac_address(const std::string& vrf,
+std::optional<mac_address_t> system::get_mac_address([[maybe_unused]] const std::string& vrf,
                                                      const ip_address_t& address)
 {
-	(void)vrf; ///< @todo: VRF
-
 	if (address.is_ipv4())
 	{
 		std::array<uint8_t, 6> neighborMacAddress;
diff --git a/controlplane/main.cpp b/controlplane/main.cpp
index d5288f79..7abb8577 100644
--- a/controlplane/main.cpp
+++ b/controlplane/main.cpp
@@ -1,8 +1,6 @@
-#include <signal.h>
+#include <csignal>
 #include <systemd/sd-daemon.h>
 
-#include <iostream>
-
 #include "controlplane.h"
 
 cControlPlane application;
@@ -49,7 +47,7 @@ int main(int argc,
 	/** @todo
 	if (signal(SIGINT, handleSignal) == SIG_ERR)
 	{
-		return 3;
+	        return 3;
 	}
 	*/
 
diff --git a/controlplane/memory_manager.cpp b/controlplane/memory_manager.cpp
index 4f2990d9..a41d1f15 100644
--- a/controlplane/memory_manager.cpp
+++ b/controlplane/memory_manager.cpp
@@ -2,11 +2,9 @@
 
 using namespace controlplane::memory_manager;
 
-void memory_manager::reload(const base_t& base_prev,
+void memory_manager::reload([[maybe_unused]] const base_t& base_prev,
                             const base_t& base_next,
-                            common::idp::updateGlobalBase::request& globalbase)
+                            [[maybe_unused]] common::idp::updateGlobalBase::request& globalbase)
 {
-	(void)base_prev;
-	(void)globalbase;
 	dataplane.memory_manager_update(base_next.root_memory_group);
 }
diff --git a/controlplane/module.cpp b/controlplane/module.cpp
index 6d6c1f71..2622ea41 100644
--- a/controlplane/module.cpp
+++ b/controlplane/module.cpp
@@ -6,10 +6,6 @@ cModule::cModule() :
 {
 }
 
-cModule::~cModule()
-{
-}
-
 eResult cModule::moduleInit(cControlPlane* controlPlane)
 {
 	this->controlPlane = controlPlane;
@@ -66,27 +62,22 @@ void cModule::moduleJoin()
 	join();
 }
 
-void cModule::limit(common::icp::limit_summary::response& limits) const
+void cModule::limit([[maybe_unused]] common::icp::limit_summary::response& limits) const
 {
-	(void)limits;
 }
 
-void cModule::controlplane_values(common::icp::controlplane_values::response& controlplane_values) const
+void cModule::controlplane_values([[maybe_unused]] common::icp::controlplane_values::response& controlplane_values) const
 {
-	(void)controlplane_values;
 }
 
 void cModule::reload_before()
 {
 }
 
-void cModule::reload(const controlplane::base_t& base_prev,
-                     const controlplane::base_t& base_next,
-                     common::idp::updateGlobalBase::request& globalbase)
+void cModule::reload([[maybe_unused]] const controlplane::base_t& base_prev,
+                     [[maybe_unused]] const controlplane::base_t& base_next,
+                     [[maybe_unused]] common::idp::updateGlobalBase::request& globalbase)
 {
-	(void)base_prev;
-	(void)base_next;
-	(void)globalbase;
 }
 
 void cModule::reload_after()
diff --git a/controlplane/module.h b/controlplane/module.h
index fd107bdc..1fc336b5 100644
--- a/controlplane/module.h
+++ b/controlplane/module.h
@@ -20,7 +20,7 @@ class cModule
 {
 public:
 	cModule();
-	virtual ~cModule();
+	virtual ~cModule() = default;
 
 	eResult moduleInit(cControlPlane* controlPlane);
 	void moduleStart();
diff --git a/controlplane/nat46clat.cpp b/controlplane/nat46clat.cpp
index 54f19af0..cdbf0753 100644
--- a/controlplane/nat46clat.cpp
+++ b/controlplane/nat46clat.cpp
@@ -3,11 +3,9 @@
 
 using namespace nat46clat;
 
-void generation_config::update(const controlplane::base_t& base_prev,
+void generation_config::update([[maybe_unused]] const controlplane::base_t& base_prev,
                                const controlplane::base_t& base_next)
 {
-	(void)base_prev;
-
 	config_nat46clats = base_next.nat46clats;
 
 	for (const auto& [module_name, nat46clat] : base_next.nat46clats)
@@ -55,14 +53,14 @@ void manager::reload(const controlplane::base_t& base_prev,
 
 	for (const auto& [module_name, nat46clat] : base_next.nat46clats)
 	{
-		(void)nat46clat;
+		YANET_GCC_BUG_UNUSED(nat46clat);
 
 		module_counters.insert(module_name);
 	}
 
 	for (const auto& [module_name, nat46clat] : base_prev.nat46clats)
 	{
-		(void)nat46clat;
+		YANET_GCC_BUG_UNUSED(nat46clat);
 
 		module_counters.remove(module_name);
 	}
diff --git a/controlplane/nat64stateful.cpp b/controlplane/nat64stateful.cpp
index 23e2c96e..f7f66d1a 100644
--- a/controlplane/nat64stateful.cpp
+++ b/controlplane/nat64stateful.cpp
@@ -33,14 +33,14 @@ void nat64stateful_t::reload(const controlplane::base_t& base_prev,
 
 	for (const auto& [name, nat64stateful] : base_next.nat64statefuls)
 	{
-		(void)nat64stateful;
+		YANET_GCC_BUG_UNUSED(nat64stateful);
 
 		module_counters.insert(name);
 	}
 
 	for (const auto& [name, nat64stateful] : base_prev.nat64statefuls)
 	{
-		(void)nat64stateful;
+		YANET_GCC_BUG_UNUSED(nat64stateful);
 
 		module_counters.remove(name);
 	}
diff --git a/controlplane/nat64stateful.h b/controlplane/nat64stateful.h
index c5be76c3..41b5a4bd 100644
--- a/controlplane/nat64stateful.h
+++ b/controlplane/nat64stateful.h
@@ -10,7 +10,6 @@
 #include "common/generation.h"
 #include "common/icp.h"
 #include "common/idataplane.h"
-#include "common/refarray.h"
 
 namespace nat64stateful
 {
@@ -20,11 +19,9 @@ using module_counter_key_t = std::string; ///< module_name
 class generation_config_t
 {
 public:
-	void update(const controlplane::base_t& base_prev,
+	void update([[maybe_unused]] const controlplane::base_t& base_prev,
 	            const controlplane::base_t& base_next)
 	{
-		(void)base_prev;
-
 		config_nat64statefuls = base_next.nat64statefuls;
 
 		for (const auto& [name, nat64stateful] : base_next.nat64statefuls)
diff --git a/controlplane/protobus.cpp b/controlplane/protobus.cpp
index d0316793..79b37f43 100644
--- a/controlplane/protobus.cpp
+++ b/controlplane/protobus.cpp
@@ -1,7 +1,6 @@
 #include <vector>
 
 #include <fcntl.h>
-#include <inttypes.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
@@ -101,7 +100,7 @@ void protoBus::clientThread(int clientSocket)
 
 	for (;;)
 	{
-		uint64_t messageSize;
+		uint64_t messageSize = 0;
 		if (auto err = common::recvAll(clientSocket, (char*)&messageSize, sizeof(messageSize)); err != 0)
 		{
 			if (err > 0)
diff --git a/controlplane/protobus.h b/controlplane/protobus.h
index 921e9bac..e24b7c4f 100644
--- a/controlplane/protobus.h
+++ b/controlplane/protobus.h
@@ -1,12 +1,8 @@
 #pragma once
 
-#include "common/icp.h"
-
 #include "module.h"
 
-namespace controlplane
-{
-namespace module
+namespace controlplane::module
 {
 
 class protoBus : public cModule
@@ -27,4 +23,3 @@ class protoBus : public cModule
 };
 
 }
-}
diff --git a/controlplane/rib.cpp b/controlplane/rib.cpp
index c66e21ed..2576a699 100644
--- a/controlplane/rib.cpp
+++ b/controlplane/rib.cpp
@@ -3,14 +3,6 @@
 
 using namespace controlplane::module;
 
-rib_t::rib_t()
-{
-}
-
-rib_t::~rib_t()
-{
-}
-
 eResult rib_t::init()
 {
 	controlPlane->register_command(common::icp::requestType::rib_update, [this](const common::icp::request& request) {
@@ -72,13 +64,10 @@ eResult rib_t::init()
 	return eResult::success;
 }
 
-void rib_t::reload(const controlplane::base_t& base_prev,
+void rib_t::reload([[maybe_unused]] const controlplane::base_t& base_prev,
                    const controlplane::base_t& base_next,
-                   common::idp::updateGlobalBase::request& globalbase)
+                   [[maybe_unused]] common::idp::updateGlobalBase::request& globalbase)
 {
-	(void)base_prev;
-	(void)globalbase;
-
 	common::icp::rib_update::request request;
 
 	{
@@ -184,7 +173,7 @@ void rib_t::rib_insert(const common::icp::rib_update::insert& request)
 			for (const auto& [nexthop, nlris] : nexthops)
 			{
 				auto& [summary_prefixes, summary_paths, summary_eor] = this->summary[{vrf, priority, protocol, peer, table_name}];
-				(void)summary_eor;
+				YANET_GCC_BUG_UNUSED(summary_eor);
 
 				for (const auto& [prefix, path_information, labels] : nlris)
 				{
@@ -284,13 +273,13 @@ void rib_t::rib_remove(const common::icp::rib_update::remove& request)
 			}
 
 			auto& [summary_prefixes, summary_paths, summary_eor] = this->summary[{vrf, priority, protocol, peer, table_name}];
-			(void)summary_eor;
+			YANET_GCC_BUG_UNUSED(summary_eor);
 
 			rib::pptn_t current_pptn = {protocol, peer, table_name};
 
 			for (const auto& [prefix, path_information, labels] : nlris)
 			{
-				(void)labels;
+				YANET_GCC_BUG_UNUSED(labels);
 
 				unsigned int prefixes_diff = 0;
 				unsigned int paths_diff = 0;
@@ -379,9 +368,9 @@ void rib_t::rib_clear(const common::icp::rib_update::clear& request)
 		{
 			const auto& [vrf, priority, protocol, peer, table_name] = summary_key;
 			auto& [summary_prefixes, summary_paths, summary_eor] = summary_value;
-			(void)table_name;
-			(void)summary_prefixes;
-			(void)summary_paths;
+			YANET_GCC_BUG_UNUSED(table_name);
+			YANET_GCC_BUG_UNUSED(summary_prefixes);
+			YANET_GCC_BUG_UNUSED(summary_paths);
 
 			if (protocol != request_protocol)
 			{
@@ -416,7 +405,7 @@ void rib_t::rib_clear(const common::icp::rib_update::clear& request)
 			if (request_attribute)
 			{
 				const auto& [request_peer, request_vrf_priority] = *request_attribute;
-				(void)request_peer;
+				YANET_GCC_BUG_UNUSED(request_peer);
 
 				if (request_vrf_priority != vrf_priority)
 				{
@@ -431,7 +420,7 @@ void rib_t::rib_clear(const common::icp::rib_update::clear& request)
 				for (auto& [pptn_index, path_info_to_nh_ptr] : pptn_to_path_info_to_nh_ptr)
 				{
 					const auto& [protocol, peer, table_name] = proto_peer_table_name[pptn_index];
-					(void)table_name;
+					YANET_GCC_BUG_UNUSED(table_name);
 
 					if (request_protocol != protocol)
 					{
@@ -441,7 +430,7 @@ void rib_t::rib_clear(const common::icp::rib_update::clear& request)
 					if (request_attribute)
 					{
 						const auto& [request_peer, request_vrf_priority] = request_attribute.value();
-						(void)request_vrf_priority;
+						YANET_GCC_BUG_UNUSED(request_vrf_priority);
 
 						if (request_peer != peer)
 						{
@@ -451,7 +440,7 @@ void rib_t::rib_clear(const common::icp::rib_update::clear& request)
 
 					for (auto& [path_info, nh_ptr] : path_info_to_nh_ptr)
 					{
-						(void)path_info;
+						YANET_GCC_BUG_UNUSED(path_info);
 						--nh_to_ref_count[*nh_ptr];
 
 						// nexthop stuff is not referenced by any prefix anymore - remove it entirely
@@ -513,8 +502,8 @@ void rib_t::rib_clear(const common::icp::rib_update::clear& request)
 		for (auto& [summary_key, summary_value] : this->summary)
 		{
 			const auto& [vrf, priority, protocol, peer, table_name] = summary_key;
-			(void)summary_value;
-			(void)table_name;
+			YANET_GCC_BUG_UNUSED(summary_value);
+			YANET_GCC_BUG_UNUSED(table_name);
 
 			if (protocol != request_protocol)
 			{
@@ -553,15 +542,15 @@ void rib_t::rib_eor(const common::icp::rib_update::eor& request)
 	const auto& [protocol, vrf, priority, peer, table_name] = request;
 
 	auto& [summary_prefixes, summary_paths, summary_eor] = this->summary[{vrf, priority, protocol, peer, table_name}];
-	(void)summary_prefixes;
-	(void)summary_paths;
+	YANET_GCC_BUG_UNUSED(summary_prefixes);
+	YANET_GCC_BUG_UNUSED(summary_paths);
 
 	summary_eor = true;
 }
 
 void rib_t::rib_flush(bool force_flush)
 {
-	bool flush;
+	bool flush = false;
 	{
 		std::lock_guard<std::mutex> rib_update_guard(rib_update_mutex);
 		std::lock_guard<std::mutex> prefixes_guard(prefixes_mutex);
@@ -579,14 +568,14 @@ void rib_t::rib_flush(bool force_flush)
 
 					controlPlane->route.prefix_update(vrf_priority, updated_prefix, proto_peer_table_name, destination);
 					controlPlane->route.tunnel_prefix_update(vrf_priority, updated_prefix, destination);
-					//controlPlane->route.linux_prefix_update(vrf_priority, updated_prefix, destination);
+					// controlPlane->route.linux_prefix_update(vrf_priority, updated_prefix, destination);
 					controlPlane->dregress.prefix_insert(vrf_priority, updated_prefix, destination);
 				}
 				else
 				{
 					controlPlane->route.prefix_update(vrf_priority, updated_prefix, {}, std::monostate()); // TODO: get rid of third parameter
 					controlPlane->route.tunnel_prefix_update(vrf_priority, updated_prefix, std::monostate());
-					//controlPlane->route.linux_prefix_update(vrf_priority, updated_prefix, std::monostate());
+					// controlPlane->route.linux_prefix_update(vrf_priority, updated_prefix, std::monostate());
 					controlPlane->dregress.prefix_remove(vrf_priority, updated_prefix);
 				}
 			}
@@ -659,7 +648,7 @@ common::icp::rib_lookup::response rib_t::rib_lookup(const common::icp::rib_looku
 		for (const auto& [vrf_priority, prefixes_to_pptn_to_path_info_to_nh_ptr] : prefixes_to_path_info_to_nh_ptr)
 		{
 			const auto& [vrf, priority] = vrf_priority;
-			(void)priority;
+			YANET_GCC_BUG_UNUSED(priority);
 
 			if (request_vrf != vrf)
 			{
@@ -702,7 +691,7 @@ common::icp::rib_get::response rib_t::rib_get(const common::icp::rib_get::reques
 	for (const auto& [vrf_priority, prefixes_to_pptn_to_path_info_to_nh_ptr] : prefixes_to_path_info_to_nh_ptr)
 	{
 		const auto& [vrf, priority] = vrf_priority;
-		(void)priority;
+		YANET_GCC_BUG_UNUSED(priority);
 
 		if (request_vrf != vrf)
 		{
@@ -819,7 +808,7 @@ void rib_t::rib_load(const common::icp::rib_load::request& request)
 		{
 			for (const auto& [prefix, pptn_to_path_info_to_nh_ptr] : prefixes_to_pptn_to_path_info_to_nh_ptr)
 			{
-				(void)pptn_to_path_info_to_nh_ptr;
+				YANET_GCC_BUG_UNUSED(pptn_to_path_info_to_nh_ptr);
 				this->prefixes_reb[vrf_priority].insert(prefix);
 			}
 		}
@@ -834,7 +823,7 @@ void rib_t::rib_load(const common::icp::rib_load::request& request)
 		{
 			const auto& [index, ref_count] = index_ref_count_pair;
 			auto [nh_to_ref_count_it, insert_result] = this->nh_to_ref_count.insert({nh, ref_count});
-			(void)insert_result;
+			YANET_GCC_BUG_UNUSED(insert_result);
 
 			const rib::nexthop_stuff_t* nh_ptr = &(nh_to_ref_count_it->first);
 
diff --git a/controlplane/rib.h b/controlplane/rib.h
index b2147c3c..5013421e 100644
--- a/controlplane/rib.h
+++ b/controlplane/rib.h
@@ -1,22 +1,8 @@
 #pragma once
 
-#include <array>
+#include "module.h"
 #include <atomic>
-#include <functional>
-#include <map>
 #include <mutex>
-#include <set>
-#include <tuple>
-#include <unordered_map>
-#include <unordered_set>
-
-#include "common/icp.h"
-#include "common/idataplane.h"
-#include "common/idp.h"
-
-#include "isystem.h"
-#include "module.h"
-#include "type.h"
 
 namespace rib
 {
@@ -36,8 +22,8 @@ using path_info_to_nexthop_stuff_ptr_t = common::rib::path_info_to_nexthop_stuff
 class rib_t : public cModule
 {
 public:
-	rib_t();
-	~rib_t() override;
+	rib_t() = default;
+	~rib_t() override = default;
 
 	eResult init() override;
 	void reload(const controlplane::base_t& base_prev, const controlplane::base_t& base_next, common::idp::updateGlobalBase::request& globalbase) override;
diff --git a/controlplane/route.cpp b/controlplane/route.cpp
index 6b12cbc5..73e0380b 100644
--- a/controlplane/route.cpp
+++ b/controlplane/route.cpp
@@ -1,5 +1,7 @@
 #include "route.h"
+#include "common/icp.h"
 #include "controlplane.h"
+#include "controlplane/route.h"
 
 uint32_t ExtractPeerIdFromPathInformation(const std::string& path_information)
 {
@@ -99,7 +101,7 @@ void route_t::prefix_update(const std::tuple<std::string, uint32_t>& vrf_priorit
 				auto current_guard = generations.current_lock_guard();
 				for (const auto& [name, module] : generations.current().routes) ///< @todo: DELETE
 				{
-					(void)name;
+					YANET_GCC_BUG_UNUSED(name);
 
 					if (exist(module.ignore_tables, table_name))
 					{
@@ -118,8 +120,8 @@ void route_t::prefix_update(const std::tuple<std::string, uint32_t>& vrf_priorit
 				uint32_t peer_id = ExtractPeerIdFromPathInformation(path_info);
 
 				const auto& [nexthop, labels, origin, med, aspath, communities, large_communities, local_preference] = *nh_ptr;
-				(void)communities;
-				(void)large_communities;
+				YANET_GCC_BUG_UNUSED(communities);
+				YANET_GCC_BUG_UNUSED(large_communities);
 
 				interface_destination_next[{std::numeric_limits<decltype(local_preference)>::max() - local_preference,
 				                            aspath.size(),
@@ -213,12 +215,12 @@ void route_t::tunnel_prefix_update(const std::tuple<std::string, uint32_t>& vrf_
 
 		for (const auto& [pptn_index, path_info_to_nh_ptr] : *nexthops)
 		{
-			(void)pptn_index;
+			YANET_GCC_BUG_UNUSED(pptn_index);
 
 			for (const auto& [path_information, nh_ptr] : path_info_to_nh_ptr)
 			{
 				const auto& [nexthop, labels, origin, med, aspath, communities, large_communities, local_preference] = *nh_ptr;
-				(void)communities;
+				YANET_GCC_BUG_UNUSED(communities);
 
 				if ((prefix.is_ipv4() && nexthop.is_ipv4()) ||
 				    (prefix.is_ipv4() && nexthop.is_ipv6()) ||
@@ -457,7 +459,7 @@ common::icp::route_lookup::response route_t::route_lookup(const common::icp::rou
 		if (exist(prefixes, vrf))
 		{
 			const auto& [priority_current, update] = prefixes[vrf];
-			(void)update;
+			YANET_GCC_BUG_UNUSED(update);
 
 			for (auto it = priority_current.rbegin();
 			     it != priority_current.rend();
@@ -517,7 +519,7 @@ common::icp::route_get::response route_t::route_get(const common::icp::route_get
 		if (exist(prefixes, vrf))
 		{
 			const auto& [priority_current, update] = prefixes[vrf];
-			(void)update;
+			YANET_GCC_BUG_UNUSED(update);
 
 			for (auto it = priority_current.rbegin();
 			     it != priority_current.rend();
@@ -582,8 +584,8 @@ common::icp::route_tunnel_counters::response route_t::route_tunnel_counters()
 	for (const auto& [key, counts] : counter_values)
 	{
 		const auto [is_ipv4, link_id, nexthop, origin_as] = key;
-		(void)is_ipv4;
-		(void)origin_as;
+		YANET_GCC_BUG_UNUSED(is_ipv4);
+		YANET_GCC_BUG_UNUSED(origin_as);
 		if (counts[0] != 0 || counts[1] != 0)
 		{
 			result.emplace_back(link_id, nexthop, counts[0], counts[1]);
@@ -665,7 +667,7 @@ common::icp::route_tunnel_lookup::response route_t::route_tunnel_lookup(const co
 		if (exist(tunnel_prefixes, vrf))
 		{
 			const auto& [priority_current, update] = tunnel_prefixes[vrf];
-			(void)update;
+			YANET_GCC_BUG_UNUSED(update);
 
 			for (auto it = priority_current.rbegin();
 			     it != priority_current.rend();
@@ -684,7 +686,7 @@ common::icp::route_tunnel_lookup::response route_t::route_tunnel_lookup(const co
 
 						for (const auto& [nexthop, egress_interface_name, label, peer_id, origin_as, weight_percent] : destinations)
 						{
-							(void)origin_as;
+							YANET_GCC_BUG_UNUSED(origin_as);
 
 							std::optional<uint32_t> result_label;
 							std::optional<std::string> result_peer;
@@ -743,7 +745,7 @@ common::icp::route_tunnel_get::response route_t::route_tunnel_get(const common::
 		if (exist(tunnel_prefixes, vrf))
 		{
 			const auto& [priority_current, update] = tunnel_prefixes[vrf];
-			(void)update;
+			YANET_GCC_BUG_UNUSED(update);
 
 			for (auto it = priority_current.rbegin();
 			     it != priority_current.rend();
@@ -762,7 +764,7 @@ common::icp::route_tunnel_get::response route_t::route_tunnel_get(const common::
 
 						for (const auto& [nexthop, egress_interface_name, label, peer_id, origin_as, weight_percent] : destinations)
 						{
-							(void)origin_as;
+							YANET_GCC_BUG_UNUSED(origin_as);
 
 							std::optional<uint32_t> result_label;
 							std::optional<std::string> result_peer;
@@ -894,7 +896,7 @@ void route_t::reload(const controlplane::base_t& base_prev,
 
 		for (const auto& [module_name, nat64stateless] : base_prev.nat64statelesses)
 		{
-			(void)module_name;
+			YANET_GCC_BUG_UNUSED(module_name);
 
 			for (const auto& prefix : nat64stateless.nat64_prefixes)
 			{
@@ -911,7 +913,7 @@ void route_t::reload(const controlplane::base_t& base_prev,
 
 		for (const auto& [module_name, nat64stateless] : base_next.nat64statelesses)
 		{
-			(void)module_name;
+			YANET_GCC_BUG_UNUSED(module_name);
 
 			for (const auto& prefix : nat64stateless.nat64_prefixes)
 			{
@@ -928,7 +930,7 @@ void route_t::reload(const controlplane::base_t& base_prev,
 
 		for (const auto& [config_module_name, config_module] : base_prev.routes)
 		{
-			(void)config_module_name;
+			YANET_GCC_BUG_UNUSED(config_module_name);
 
 			for (const auto& prefix : config_module.local_prefixes)
 			{
@@ -940,7 +942,7 @@ void route_t::reload(const controlplane::base_t& base_prev,
 
 		for (const auto& [config_module_name, config_module] : base_next.routes)
 		{
-			(void)config_module_name;
+			YANET_GCC_BUG_UNUSED(config_module_name);
 
 			for (const auto& prefix : config_module.local_prefixes)
 			{
@@ -952,11 +954,11 @@ void route_t::reload(const controlplane::base_t& base_prev,
 
 		for (const auto& [config_module_name, config_module] : base_prev.routes)
 		{
-			(void)config_module_name;
+			YANET_GCC_BUG_UNUSED(config_module_name);
 
 			for (const auto& [interface_name, interface] : config_module.interfaces)
 			{
-				(void)interface_name;
+				YANET_GCC_BUG_UNUSED(interface_name);
 
 				for (const auto& ip_prefix : interface.ip_prefixes)
 				{
@@ -973,7 +975,7 @@ void route_t::reload(const controlplane::base_t& base_prev,
 
 		for (const auto& [config_module_name, config_module] : base_next.routes)
 		{
-			(void)config_module_name;
+			YANET_GCC_BUG_UNUSED(config_module_name);
 
 			for (const auto& [interface_name, interface] : config_module.interfaces)
 			{
@@ -1025,7 +1027,7 @@ void route_t::prefix_flush_prefixes(common::idp::updateGlobalBase::request& glob
 
 	for (auto& [vrf, priority_current_update] : prefixes)
 	{
-		(void)vrf; ///< @todo: VRF
+		YANET_GCC_BUG_UNUSED(vrf); ///< @todo: VRF
 
 		auto& [priority_current, update] = priority_current_update;
 
@@ -1051,7 +1053,7 @@ void route_t::prefix_flush_prefixes(common::idp::updateGlobalBase::request& glob
 
 			for (const auto& [priority, current] : priority_current)
 			{
-				(void)priority;
+				YANET_GCC_BUG_UNUSED(priority);
 
 				for (const auto& update_prefix : update_prefixes)
 				{
@@ -1091,7 +1093,7 @@ void route_t::tunnel_prefix_flush_prefixes(common::idp::updateGlobalBase::reques
 
 	for (auto& [vrf, priority_current_update] : tunnel_prefixes)
 	{
-		(void)vrf; ///< @todo: VRF
+		YANET_GCC_BUG_UNUSED(vrf); ///< @todo: VRF
 
 		auto& [priority_current, update] = priority_current_update;
 
@@ -1117,7 +1119,7 @@ void route_t::tunnel_prefix_flush_prefixes(common::idp::updateGlobalBase::reques
 
 			for (const auto& [priority, current] : priority_current)
 			{
-				(void)priority;
+				YANET_GCC_BUG_UNUSED(priority);
 
 				for (const auto& update_prefix : update_prefixes)
 				{
@@ -1171,15 +1173,15 @@ std::optional<uint32_t> route_t::value_insert(const route::value_key_t& value_ke
 	}
 
 	const auto& [vrf_priority, destination, fallback] = value_key;
-	(void)vrf_priority;
-	(void)fallback;
+	YANET_GCC_BUG_UNUSED(vrf_priority);
+	YANET_GCC_BUG_UNUSED(fallback);
 
 	/// counters
 	if (const auto nexthops = std::get_if<route::destination_interface_t>(&destination))
 	{
 		for (const auto& [nexthop, peer_id, prefix, labels] : *nexthops)
 		{
-			(void)labels;
+			YANET_GCC_BUG_UNUSED(labels);
 
 			route_counter.insert({peer_id, nexthop, prefix});
 		}
@@ -1194,15 +1196,15 @@ void route_t::value_remove(const uint32_t& value_id)
 	if (value_key)
 	{
 		const auto& [vrf_priority, destination, fallback] = *value_key;
-		(void)vrf_priority;
-		(void)fallback;
+		YANET_GCC_BUG_UNUSED(vrf_priority);
+		YANET_GCC_BUG_UNUSED(fallback);
 
 		/// counters
 		if (const auto nexthops = std::get_if<route::destination_interface_t>(&destination))
 		{
 			for (const auto& [nexthop, peer_id, prefix, labels] : *nexthops)
 			{
-				(void)labels;
+				YANET_GCC_BUG_UNUSED(labels);
 
 				route_counter.remove({peer_id, nexthop, prefix}, 20);
 			}
@@ -1315,7 +1317,7 @@ void route_t::value_compile(common::idp::updateGlobalBase::request& globalbase,
 
 			auto& [priority_current, update] = prefixes[vrf];
 			auto& current = priority_current[priority];
-			(void)update;
+			YANET_GCC_BUG_UNUSED(update);
 
 			const auto value_id_label = current.get(prefix_next);
 			if (value_id_label)
@@ -1338,7 +1340,7 @@ void route_t::value_compile(common::idp::updateGlobalBase::request& globalbase,
 	{
 		auto& [priority_current, update] = prefixes[vrf];
 		auto& current = priority_current[priority];
-		(void)update;
+		YANET_GCC_BUG_UNUSED(update);
 
 		const auto value_id_fallback = current.get(fallback);
 		if (value_id_fallback)
@@ -1447,9 +1449,9 @@ void route_t::value_compile_label(common::idp::updateGlobalBase::request& global
 {
 	const auto& value_key = values.get_value(value_id);
 	const auto& [vrf_priority, destination, fallback] = value_key;
-	(void)globalbase;
-	(void)vrf_priority;
-	(void)fallback;
+	YANET_GCC_BUG_UNUSED(globalbase);
+	YANET_GCC_BUG_UNUSED(vrf_priority);
+	YANET_GCC_BUG_UNUSED(fallback);
 
 	if (const auto virtual_port_id = std::get_if<uint32_t>(&destination))
 	{
@@ -1500,9 +1502,9 @@ void route_t::value_compile_fallback(common::idp::updateGlobalBase::request& glo
 {
 	const auto& value_key = values.get_value(value_id);
 	const auto& [vrf_priority, destination, fallback] = value_key;
-	(void)globalbase;
-	(void)vrf_priority;
-	(void)fallback;
+	YANET_GCC_BUG_UNUSED(globalbase);
+	YANET_GCC_BUG_UNUSED(vrf_priority);
+	YANET_GCC_BUG_UNUSED(fallback);
 
 	if (const auto virtual_port_id = std::get_if<uint32_t>(&destination))
 	{
@@ -1552,15 +1554,15 @@ std::optional<uint32_t> route_t::tunnel_value_insert(const route::tunnel_value_k
 	}
 
 	const auto& [vrf_priority, destination, fallback] = value_key;
-	(void)vrf_priority;
+	YANET_GCC_BUG_UNUSED(vrf_priority);
 
 	/// counters
 	if (const auto nexthops = std::get_if<route::tunnel_destination_interface_t>(&destination))
 	{
 		for (const auto& [nexthop, label, peer_id, origin_as, weight] : *nexthops)
 		{
-			(void)label;
-			(void)weight;
+			YANET_GCC_BUG_UNUSED(label);
+			YANET_GCC_BUG_UNUSED(weight);
 
 			tunnel_counter.insert({fallback.is_ipv4(), peer_id, nexthop, origin_as});
 		}
@@ -1575,15 +1577,15 @@ void route_t::tunnel_value_remove(const uint32_t& value_id)
 	if (value_key)
 	{
 		const auto& [vrf_priority, destination, fallback] = *value_key;
-		(void)vrf_priority;
+		YANET_GCC_BUG_UNUSED(vrf_priority);
 
 		/// counters
 		if (const auto nexthops = std::get_if<route::tunnel_destination_interface_t>(&destination))
 		{
 			for (const auto& [nexthop, label, peer_id, origin_as, weight] : *nexthops)
 			{
-				(void)label;
-				(void)weight;
+				YANET_GCC_BUG_UNUSED(label);
+				YANET_GCC_BUG_UNUSED(weight);
 
 				tunnel_counter.remove({fallback.is_ipv4(), peer_id, nexthop, origin_as}, 20);
 			}
@@ -1599,7 +1601,7 @@ void route_t::tunnel_value_compile(common::idp::updateGlobalBase::request& globa
 	std::vector<route::tunnel_value_interface_t> request_interface;
 
 	const auto& [vrf_priority, destination, fallback] = value_key;
-	(void)vrf_priority; ///< @todo: VRF
+	YANET_GCC_BUG_UNUSED(vrf_priority); ///< @todo: VRF
 
 	tunnel_value_lookup[value_id].clear();
 
@@ -1810,7 +1812,7 @@ void route_t::tunnel_value_compile(common::idp::updateGlobalBase::request& globa
 		for (const auto& item : request_interface)
 		{
 			const auto& [nexthop, egress_interface_id, label, egress_interface_name, peer_id, origin_as, weight, neighbor_address] = item;
-			(void)egress_interface_name;
+			YANET_GCC_BUG_UNUSED(egress_interface_name);
 
 			if (exist(interfaces, egress_interface_id))
 			{
@@ -1842,7 +1844,7 @@ void route_t::tunnel_value_compile(common::idp::updateGlobalBase::request& globa
 			for (const auto& item : request_interface)
 			{
 				const auto& [nexthop, egress_interface_id, label, egress_interface_name, peer_id, origin_as, weight, neighbor_address] = item;
-				(void)egress_interface_name;
+				YANET_GCC_BUG_UNUSED(egress_interface_name);
 
 				const auto counter_id = tunnel_counter.get_id({fallback.is_ipv4(), peer_id, nexthop, origin_as});
 
@@ -1878,12 +1880,12 @@ void route_t::tunnel_value_compile(common::idp::updateGlobalBase::request& globa
 
 		for (auto& [nexthop, egress_interface_name, label, peer_id, origin_as, weight_percent] : tunnel_value_lookup[value_id][socket_id])
 		{
-			(void)socket_id;
-			(void)nexthop;
-			(void)egress_interface_name;
-			(void)label;
-			(void)peer_id;
-			(void)origin_as;
+			YANET_GCC_BUG_UNUSED(socket_id);
+			YANET_GCC_BUG_UNUSED(nexthop);
+			YANET_GCC_BUG_UNUSED(egress_interface_name);
+			YANET_GCC_BUG_UNUSED(label);
+			YANET_GCC_BUG_UNUSED(peer_id);
+			YANET_GCC_BUG_UNUSED(origin_as);
 
 			if (weight_is_fallback)
 			{
@@ -1907,16 +1909,16 @@ std::set<std::string> route_t::get_ingress_physical_ports(const tSocketId& socke
 
 	/// @todo: use function
 	const auto& [dataplane_physicalports, dataplane_workers, dataplane_values] = controlPlane->dataPlaneConfig;
-	(void)dataplane_workers;
-	(void)dataplane_values;
+	YANET_GCC_BUG_UNUSED(dataplane_workers);
+	YANET_GCC_BUG_UNUSED(dataplane_values);
 
 	for (const auto& [dataplane_physicalport_id, dataplane_physicalport] : dataplane_physicalports)
 	{
-		(void)dataplane_physicalport_id;
+		YANET_GCC_BUG_UNUSED(dataplane_physicalport_id);
 
 		const auto& [physicalport_name, dataplane_socket_id, mac_address, pci] = dataplane_physicalport;
-		(void)mac_address;
-		(void)pci;
+		YANET_GCC_BUG_UNUSED(mac_address);
+		YANET_GCC_BUG_UNUSED(pci);
 
 		if (socket_id != dataplane_socket_id)
 		{
diff --git a/controlplane/route.h b/controlplane/route.h
index 87a87253..890bb7e9 100644
--- a/controlplane/route.h
+++ b/controlplane/route.h
@@ -2,6 +2,7 @@
 
 #include "base.h"
 #include "counter.h"
+#include "isystem.h"
 #include "module.h"
 #include "rib.h"
 #include "type.h"
@@ -97,20 +98,16 @@ using tunnel_counter_key_t = std::tuple<bool, ///< is_ipv4
 class generation_t
 {
 public:
-	generation_t()
-	{
-	}
+	generation_t() = default;
 
-	void update(const controlplane::base_t& base_prev,
+	void update([[maybe_unused]] const controlplane::base_t& base_prev,
 	            const controlplane::base_t& base_next)
 	{
-		(void)base_prev;
-
 		routes = base_next.routes;
 
 		for (const auto& [module_name, route] : base_next.routes)
 		{
-			(void)module_name;
+			YANET_GCC_BUG_UNUSED(module_name);
 
 			for (const auto& [interface_name, interface] : route.interfaces)
 			{
@@ -143,7 +140,7 @@ class generation_t
 		socket_interfaces = base_next.socket_interfaces;
 	}
 
-	std::optional<const std::tuple<tInterfaceId, std::string>*> get_interface_by_neighbor(const ip_address_t& address) const
+	[[nodiscard]] std::optional<const std::tuple<tInterfaceId, std::string>*> get_interface_by_neighbor(const ip_address_t& address) const
 	{
 		for (const auto& [prefix, interface] : interface_by_neighbors)
 		{
@@ -156,7 +153,7 @@ class generation_t
 		return std::nullopt;
 	}
 
-	std::optional<const std::string*> get_vrf(const std::string& route_name) const
+	[[nodiscard]] std::optional<const std::string*> get_vrf(const std::string& route_name) const
 	{
 		auto it = routes.find(route_name);
 		if (it == routes.end())
@@ -167,7 +164,7 @@ class generation_t
 		return &it->second.vrf; ///< read only after update
 	}
 
-	const std::map<uint32_t, std::string>* get_peers() const
+	[[nodiscard]] const std::map<uint32_t, std::string>* get_peers() const
 	{
 		return &peers;
 	}
@@ -190,7 +187,7 @@ class generation_t
 class generation_neighbors_t
 {
 public:
-	std::optional<const common::mac_address_t*> get_mac_address(const std::string& route_name, const std::string& interface_name, const common::ip_address_t& neighbor) const
+	[[nodiscard]] std::optional<const common::mac_address_t*> get_mac_address(const std::string& route_name, const std::string& interface_name, const common::ip_address_t& neighbor) const
 	{
 		auto it = mac_addresses.find({route_name, interface_name, neighbor});
 		if (it == mac_addresses.end())
diff --git a/controlplane/segment_allocator.h b/controlplane/segment_allocator.h
index 78957e26..5250ef12 100644
--- a/controlplane/segment_allocator.h
+++ b/controlplane/segment_allocator.h
@@ -2,8 +2,7 @@
 
 #include <cstdint>
 #include <cstring>
-
-#include <iostream>
+#include <utility>
 
 #define ENABLE_BIT(v, b) (v) |= ((uint64_t)1) << (b)
 #define GET_BIT(v, b) (((v) >> (b)) & 1)
@@ -27,10 +26,9 @@ class SegmentAllocator
 		uint32_t used_segments = 0;
 	};
 
-	SegmentAllocator()
+	SegmentAllocator() :
+	        free_cells_(IndexEnd - IndexBegin)
 	{
-		free_cells_ = IndexEnd - IndexBegin;
-
 		// Initialize blocks in main list of free blocks and set size of each block
 		for (uint32_t index = 0; index < total_blocks_; ++index)
 		{
@@ -149,7 +147,7 @@ class SegmentAllocator
 		return true;
 	}
 
-	uint32_t Size() const
+	[[nodiscard]] uint32_t Size() const
 	{
 		return free_cells_;
 	}
@@ -159,7 +157,7 @@ class SegmentAllocator
 		return sizes_info_;
 	}
 
-	std::pair<uint64_t, uint64_t> GetErrors() const
+	[[nodiscard]] std::pair<uint64_t, uint64_t> GetErrors() const
 	{
 		return {errors_external_, errors_internal_};
 	}
diff --git a/controlplane/telegraf.cpp b/controlplane/telegraf.cpp
index ec3d9218..05dc955f 100644
--- a/controlplane/telegraf.cpp
+++ b/controlplane/telegraf.cpp
@@ -4,8 +4,7 @@
 using common::int64;
 using controlplane::module::telegraf;
 
-YANET_UNUSED
-static inline double perSecond(const int64_t& valueDiff, const uint64_t& timeDiff)
+[[maybe_unused]] static inline double perSecond(const int64_t& valueDiff, const uint64_t& timeDiff)
 {
 	if (timeDiff == 0)
 	{
@@ -52,10 +51,6 @@ telegraf_t::telegraf_t() :
 {
 }
 
-telegraf_t::~telegraf_t()
-{
-}
-
 eResult telegraf_t::init()
 {
 	controlPlane->register_command(common::icp::requestType::telegraf_unsafe, [this]() {
@@ -92,10 +87,8 @@ void telegraf_t::reload_before()
 
 void telegraf_t::reload(const controlplane::base_t& base_prev,
                         const controlplane::base_t& base_next,
-                        common::idp::updateGlobalBase::request& globalbase)
+                        [[maybe_unused]] common::idp::updateGlobalBase::request& globalbase)
 {
-	(void)globalbase;
-
 	generations.next().update(base_prev, base_next);
 }
 
@@ -145,7 +138,7 @@ common::icp::telegraf_unsafe::response telegraf_t::telegraf_unsafe()
 		{
 			const auto& [encap_packets, encap_bytes, encap_dropped, decap_packets, decap_bytes, decap_unknown] = tun64Stats.at(name);
 
-			(void)tunnel;
+			YANET_GCC_BUG_UNUSED(tunnel);
 			responseTun64[name] = {encap_packets, encap_bytes, encap_dropped, decap_packets, decap_bytes, decap_unknown};
 		}
 	}
@@ -181,7 +174,7 @@ common::icp::telegraf_mappings::response telegraf_t::telegraf_mappings()
 				const auto& [encap_packets, encap_bytes, decap_packets, decap_bytes] = counters.at({name, ipv4_address});
 				const common::tun64mapping::stats_t stats = {encap_packets, encap_bytes, decap_packets, decap_bytes};
 
-				(void)location;
+				YANET_GCC_BUG_UNUSED(location);
 				response.emplace_back(name, ipv4_address, ipv6_address, stats);
 			}
 		}
@@ -224,7 +217,7 @@ common::icp::telegraf_dregress_traffic::response telegraf_t::telegraf_dregress_t
 		{
 			const auto& [is_ipv4, peer_id, nexthop, origin_as] = key;
 			const auto& [packets, bytes] = value;
-			(void)origin_as;
+			YANET_GCC_BUG_UNUSED(origin_as);
 
 			auto it = dregress_traffic_counters_prev.find(key);
 			if (it != dregress_traffic_counters_prev.end())
@@ -310,7 +303,7 @@ common::icp::telegraf_other::response telegraf_t::telegraf_other()
 	for (const auto& [coreId, worker_info] : sdp_data->workers)
 	{
 		std::array<uint64_t, CONFIG_YADECAP_MBUFS_BURST_SIZE + 1> bursts;
-		uint64_t* worker_bursts =
+		auto* worker_bursts =
 		        common::sdp::ShiftBuffer<uint64_t*>(worker_info.buffer, sdp_data->metadata_worker.start_bursts);
 		memcpy(&bursts[0], worker_bursts, sizeof(uint64_t) * (CONFIG_YADECAP_MBUFS_BURST_SIZE + 1));
 		currWorkers[coreId] = bursts;
diff --git a/controlplane/telegraf.h b/controlplane/telegraf.h
index 926f3570..34f9f3b4 100644
--- a/controlplane/telegraf.h
+++ b/controlplane/telegraf.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <map>
-#include <mutex>
 
 #include "common/icp.h"
 #include "common/idataplane.h"
@@ -17,18 +16,14 @@ namespace telegraf
 class generation_t
 {
 public:
-	generation_t()
-	{
-	}
+	generation_t() = default;
 
-	void update(const controlplane::base_t& base_prev,
+	void update([[maybe_unused]] const controlplane::base_t& base_prev,
 	            const controlplane::base_t& base_next)
 	{
-		(void)base_prev;
-
 		for (const auto& [module_name, dregress] : base_next.dregresses)
 		{
-			(void)module_name;
+			YANET_GCC_BUG_UNUSED(module_name);
 
 			communities.insert(dregress.communities.begin(), dregress.communities.end());
 		}
@@ -36,19 +31,19 @@ class generation_t
 
 		for (const auto& [module_name, route] : base_next.routes)
 		{
-			(void)module_name;
+			YANET_GCC_BUG_UNUSED(module_name);
 
 			peers.insert(route.peers.begin(), route.peers.end());
 		}
 		peers[0] = "unknown";
 	}
 
-	const std::map<community_t, std::string>* get_communities() const
+	[[nodiscard]] const std::map<community_t, std::string>* get_communities() const
 	{
 		return &communities;
 	}
 
-	const std::map<uint32_t, std::string>* get_peers() const
+	[[nodiscard]] const std::map<uint32_t, std::string>* get_peers() const
 	{
 		return &peers;
 	}
@@ -64,7 +59,7 @@ class telegraf_t : public module_t
 {
 public:
 	telegraf_t();
-	~telegraf_t();
+	~telegraf_t() override = default;
 
 	eResult init() override;
 	void reload_before() override;
diff --git a/controlplane/tun64.cpp b/controlplane/tun64.cpp
index 09ee3968..142f9088 100644
--- a/controlplane/tun64.cpp
+++ b/controlplane/tun64.cpp
@@ -1,14 +1,6 @@
 #include "tun64.h"
 #include "controlplane.h"
 
-tun64_t::tun64_t()
-{
-}
-
-tun64_t::~tun64_t()
-{
-}
-
 eResult tun64_t::init()
 {
 	tunnel_counters.init(&controlPlane->counter_manager);
@@ -50,7 +42,7 @@ void tun64_t::reload(const controlplane::base_t& base_prev,
 
 		for (const auto& [ipv4_address, mapping] : tunnel.mappings)
 		{
-			(void)mapping;
+			YANET_GCC_BUG_UNUSED(mapping);
 			mappings_counters.insert({name, ipv4_address});
 		}
 	}
@@ -61,7 +53,7 @@ void tun64_t::reload(const controlplane::base_t& base_prev,
 
 		for (const auto& [ipv4_address, mapping] : tunnel.mappings)
 		{
-			(void)mapping;
+			YANET_GCC_BUG_UNUSED(mapping);
 			mappings_counters.remove({name, ipv4_address});
 		}
 	}
@@ -141,7 +133,7 @@ void tun64_t::compile(common::idp::updateGlobalBase::request& globalbase,
 			const auto& [ipv6_address, location] = mapping;
 			const auto counter_id = mappings_counters.get_id({name, ipv4_address});
 
-			(void)location;
+			YANET_GCC_BUG_UNUSED(location);
 			tun64mappings_update_request.emplace_back(tunnel.tun64Id,
 			                                          ipv4_address,
 			                                          ipv6_address,
diff --git a/controlplane/tun64.h b/controlplane/tun64.h
index 850c5e86..bd2a2b49 100644
--- a/controlplane/tun64.h
+++ b/controlplane/tun64.h
@@ -9,7 +9,6 @@
 #include "common/generation.h"
 #include "common/icp.h"
 #include "common/idataplane.h"
-#include "common/refarray.h"
 
 namespace tun64
 {
@@ -17,11 +16,9 @@ namespace tun64
 class generation_config_t
 {
 public:
-	void update(const controlplane::base_t& base_prev,
+	void update([[maybe_unused]] const controlplane::base_t& base_prev,
 	            const controlplane::base_t& base_next)
 	{
-		(void)base_prev;
-
 		config_tunnels = base_next.tunnels;
 	}
 
@@ -38,8 +35,8 @@ class generation_config_t
 class tun64_t : public module_t
 {
 public:
-	tun64_t();
-	~tun64_t();
+	tun64_t() = default;
+	~tun64_t() override = default;
 
 	eResult init() override;
 	void reload_before() override;
diff --git a/controlplane/type.h b/controlplane/type.h
index 1ba4e17e..ae408d95 100644
--- a/controlplane/type.h
+++ b/controlplane/type.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <array>
-
 #include "common/type.h"
 
 class cControlPlane;
diff --git a/controlplane/unittest/acl_flat.cpp b/controlplane/unittest/acl_flat.cpp
index 13fdd65b..5af4c81c 100644
--- a/controlplane/unittest/acl_flat.cpp
+++ b/controlplane/unittest/acl_flat.cpp
@@ -1,5 +1,3 @@
-#include <fstream>
-
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -8,21 +6,21 @@
 namespace
 {
 
-template<typename... args_T>
+template<typename... Args>
 void expect_group_ids_helper(std::vector<tAclGroupId>& vector,
                              const unsigned int group_id,
-                             const args_T... group_ids)
+                             const Args... group_ids)
 {
 	vector.emplace_back(group_id);
 
-	if constexpr (sizeof...(args_T) != 0)
+	if constexpr (sizeof...(Args) != 0)
 	{
 		expect_group_ids_helper(vector, group_ids...);
 	}
 }
 
-template<typename... args_T>
-std::vector<tAclGroupId> expect_group_ids(const args_T... group_ids)
+template<typename... Args>
+std::vector<tAclGroupId> expect_group_ids(const Args... group_ids)
 {
 	std::vector<tAclGroupId> result;
 	expect_group_ids_helper(result, group_ids...);
diff --git a/controlplane/unittest/acl_network.cpp b/controlplane/unittest/acl_network.cpp
index 71627e4f..4b70b732 100644
--- a/controlplane/unittest/acl_network.cpp
+++ b/controlplane/unittest/acl_network.cpp
@@ -13,21 +13,21 @@ uint128_t convert_to_uint128(const std::string& address)
 	return acl::network_t(address).addr;
 }
 
-template<typename... args_T>
+template<typename... Args>
 void make_filter_helper(acl::compiler::network_t<uint128_t>::filter& filter,
                         const std::string& prefix,
-                        const args_T&... prefixes)
+                        const Args&... prefixes)
 {
 	filter.emplace(prefix);
 
-	if constexpr (sizeof...(args_T) != 0)
+	if constexpr (sizeof...(Args) != 0)
 	{
 		make_filter_helper(filter, prefixes...);
 	}
 }
 
-template<typename... args_T>
-acl::compiler::network_t<uint128_t>::filter make_filter(const args_T&... prefixes)
+template<typename... Args>
+acl::compiler::network_t<uint128_t>::filter make_filter(const Args&... prefixes)
 {
 	acl::compiler::network_t<uint128_t>::filter result;
 	make_filter_helper(result, prefixes...);
@@ -49,21 +49,21 @@ tAclGroupId get_by_address(acl::compiler::network_t<type_t>& network,
 	return network.get_group_ids_by_address(convert_to_uint128(address));
 }
 
-template<typename... args_T>
+template<typename... Args>
 void expect_group_ids_helper(std::vector<tAclGroupId>& vector,
                              const unsigned int group_id,
-                             const args_T... group_ids)
+                             const Args... group_ids)
 {
 	vector.emplace_back(group_id);
 
-	if constexpr (sizeof...(args_T) != 0)
+	if constexpr (sizeof...(Args) != 0)
 	{
 		expect_group_ids_helper(vector, group_ids...);
 	}
 }
 
-template<typename... args_T>
-std::vector<tAclGroupId> expect_group_ids(const args_T... group_ids)
+template<typename... Args>
+std::vector<tAclGroupId> expect_group_ids(const Args... group_ids)
 {
 	std::vector<tAclGroupId> result;
 	expect_group_ids_helper(result, group_ids...);
diff --git a/controlplane/unittest/acl_table.cpp b/controlplane/unittest/acl_table.cpp
index c98fdb7d..99d37d4f 100644
--- a/controlplane/unittest/acl_table.cpp
+++ b/controlplane/unittest/acl_table.cpp
@@ -6,29 +6,29 @@
 namespace
 {
 
-template<typename... args_T>
+template<typename... Args>
 void expect_group_ids_helper(std::vector<tAclGroupId>& vector,
                              const unsigned int group_id,
-                             const args_T... group_ids)
+                             const Args... group_ids)
 {
 	vector.emplace_back(group_id);
 
-	if constexpr (sizeof...(args_T) != 0)
+	if constexpr (sizeof...(Args) != 0)
 	{
 		expect_group_ids_helper(vector, group_ids...);
 	}
 }
 
-template<typename... args_T>
-std::vector<tAclGroupId> expect_group_ids(const args_T... group_ids)
+template<typename... Args>
+std::vector<tAclGroupId> expect_group_ids(const Args... group_ids)
 {
 	std::vector<tAclGroupId> result;
 	expect_group_ids_helper(result, group_ids...);
 	return result;
 }
 
-template<typename... args_T>
-std::tuple<unsigned int, unsigned int, tAclGroupId> expect_result(const args_T... args)
+template<typename... Args>
+std::tuple<unsigned int, unsigned int, tAclGroupId> expect_result(const Args... args)
 {
 	return {args...};
 }
diff --git a/controlplane/unittest/parser.cpp b/controlplane/unittest/parser.cpp
index 14534002..4a2e1c71 100644
--- a/controlplane/unittest/parser.cpp
+++ b/controlplane/unittest/parser.cpp
@@ -1,6 +1,5 @@
 #include <gtest/gtest.h>
 
-#include "common/type.h"
 #include "libfwparser/fw_parser.h"
 
 namespace
@@ -8,7 +7,7 @@ namespace
 
 auto parse_rules(const std::string& rules, bool validation = false)
 {
-	bool ret;
+	bool ret = false;
 
 	ipfw::fw_config_t firewall;
 	firewall.schedule_string(rules);
diff --git a/controlplane/unittest/segment_allocator.cpp b/controlplane/unittest/segment_allocator.cpp
index 0af3cf37..0e203663 100644
--- a/controlplane/unittest/segment_allocator.cpp
+++ b/controlplane/unittest/segment_allocator.cpp
@@ -179,7 +179,7 @@ TEST(SegmentAllocator, BigSize)
 
 	uint8_t data[sizeof(AllocatorBig)];
 	memset((void*)data, -1, sizeof(AllocatorBig));
-	AllocatorBig* allocator = new (data) AllocatorBig();
+	auto* allocator = new (data) AllocatorBig();
 
 	uint16_t size = 4;
 	uint32_t full_size = index_end - index_begin;
diff --git a/dataplane/base.h b/dataplane/base.h
index a6de2202..0fc9934b 100644
--- a/dataplane/base.h
+++ b/dataplane/base.h
@@ -47,7 +47,7 @@ class PortMapper
 		return *this;
 	}
 
-	uint16_t size() const { return ports_count_; }
+	[[nodiscard]] uint16_t size() const { return ports_count_; }
 
 	[[nodiscard]] std::optional<tPortId> Register(tPortId dpdk_port)
 	{
@@ -72,20 +72,16 @@ class PortMapper
 		}
 	}
 
-	tPortId ToDpdk(tPortId logical) const { return dpdk_ports_[logical]; }
-	tPortId ToLogical(tPortId dpdk) const { return logical_ports_[dpdk]; }
-	bool ValidDpdk(tPortId dpdk) const { return logical_ports_[dpdk] != INVALID_PORT_ID; }
-	bool ValidLogical(tPortId logical) const { return logical < INVALID_PORT_ID; }
+	[[nodiscard]] tPortId ToDpdk(tPortId logical) const { return dpdk_ports_[logical]; }
+	[[nodiscard]] tPortId ToLogical(tPortId dpdk) const { return logical_ports_[dpdk]; }
+	[[nodiscard]] bool ValidDpdk(tPortId dpdk) const { return logical_ports_[dpdk] != INVALID_PORT_ID; }
+	[[nodiscard]] bool ValidLogical(tPortId logical) const { return logical < INVALID_PORT_ID; }
 };
 
 class permanently
 {
 public:
-	permanently() :
-	        globalBaseAtomic(nullptr),
-	        nat64stateful_numa_mask(0xFFFFu),
-	        nat64stateful_numa_reverse_mask(0),
-	        nat64stateful_numa_id(0)
+	permanently()
 	{
 		memset(globalBaseAtomics, 0, sizeof(globalBaseAtomics));
 
@@ -109,7 +105,7 @@ class permanently
 		return true;
 	}
 
-	dataplane::globalBase::atomic* globalBaseAtomic;
+	dataplane::globalBase::atomic* globalBaseAtomic{};
 	/// Pointers to all globalBaseAtomic for each CPU socket.
 	///
 	/// Used to distribute firewall states.
@@ -123,22 +119,16 @@ class permanently
 	uint32_t SWNormalPriorityRateLimitPerWorker;
 	uint8_t transportSizes[256];
 
-	uint16_t nat64stateful_numa_mask;
-	uint16_t nat64stateful_numa_reverse_mask;
-	uint16_t nat64stateful_numa_id;
+	uint16_t nat64stateful_numa_mask{0xFFFFu};
+	uint16_t nat64stateful_numa_reverse_mask{};
+	uint16_t nat64stateful_numa_id{};
 };
 
 class generation
 {
 public:
-	generation() :
-	        globalBase(nullptr),
-	        neighbor_hashtable(nullptr)
-	{
-	}
-
-	dataplane::globalBase::generation* globalBase;
-	dataplane::neighbor::hashtable const* neighbor_hashtable;
+	dataplane::globalBase::generation* globalBase{};
+	dataplane::neighbor::hashtable const* neighbor_hashtable{};
 } __rte_aligned(2 * RTE_CACHE_LINE_SIZE);
 
 }
diff --git a/dataplane/bus.cpp b/dataplane/bus.cpp
index 95a81a03..022ea4a0 100644
--- a/dataplane/bus.cpp
+++ b/dataplane/bus.cpp
@@ -57,8 +57,8 @@ void cBus::join()
 
 uint64_t cBus::GetSizeForCounters()
 {
-	uint32_t count_errors = static_cast<uint32_t>(common::idp::errorType::size);
-	uint32_t count_requests = static_cast<uint32_t>(common::idp::requestType::size);
+	auto count_errors = static_cast<uint32_t>(common::idp::errorType::size);
+	auto count_requests = static_cast<uint32_t>(common::idp::requestType::size);
 	return (count_errors + 2 * count_requests) * sizeof(uint64_t);
 }
 
@@ -160,7 +160,7 @@ void cBus::clientThread(int clientSocket)
 
 	for (;;)
 	{
-		uint64_t messageSize;
+		uint64_t messageSize = 0;
 		if (!recvAll(clientSocket, (char*)&messageSize, sizeof(messageSize)))
 		{
 			stats.errors[(uint32_t)common::idp::errorType::busRead]++;
diff --git a/dataplane/bus.h b/dataplane/bus.h
index 1a43f223..450b1c47 100644
--- a/dataplane/bus.h
+++ b/dataplane/bus.h
@@ -1,19 +1,7 @@
 #pragma once
 
-#include <arpa/inet.h>
-
-#include <array>
-#include <thread>
-#include <variant>
-#include <vector>
-
-#include <rte_ether.h>
-
-#include "common/idp.h"
-#include "common/result.h"
-
-#include "sdpserver.h"
-#include "type.h"
+#include "common/sdpcommon.h"
+#include "controlplane.h"
 
 class cBus
 {
@@ -33,9 +21,8 @@ class cBus
 	void clientThread(int clientSocket);
 
 protected:
-	void call(void (cControlPlane::*function)(), const common::idp::request& request)
+	void call(void (cControlPlane::*function)(), [[maybe_unused]] const common::idp::request& request)
 	{
-		(void)request; ///< @todo: [[maybe_unused]]
 		(controlPlane->*function)();
 	}
 
@@ -46,16 +33,14 @@ class cBus
 	}
 
 	template<typename TResult>
-	TResult callWithResponse(TResult (cControlPlane::*function)(), const common::idp::request& request)
+	TResult callWithResponse(TResult (cControlPlane::*function)(), [[maybe_unused]] const common::idp::request& request)
 	{
-		(void)request; ///< @todo: [[maybe_unused]]
 		return (controlPlane->*function)();
 	}
 
 	template<typename TResult>
-	TResult callWithResponse(TResult (cControlPlane::*function)() const, const common::idp::request& request) const
+	TResult callWithResponse(TResult (cControlPlane::*function)() const, [[maybe_unused]] const common::idp::request& request) const
 	{
-		(void)request; ///< @todo: [[maybe_unused]]
 		return (controlPlane->*function)();
 	}
 
diff --git a/dataplane/checksum.h b/dataplane/checksum.h
index caca7b9e..6ed34cec 100644
--- a/dataplane/checksum.h
+++ b/dataplane/checksum.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cinttypes>
-
 #include <rte_icmp.h>
 #include <rte_ip.h>
 #include <rte_tcp.h>
diff --git a/dataplane/common.h b/dataplane/common.h
index 2dca6b62..d38cb5e8 100644
--- a/dataplane/common.h
+++ b/dataplane/common.h
@@ -6,7 +6,7 @@
 #include <rte_ether.h>
 #include <rte_hash_crc.h>
 
-#include "common/config.h"
+#include "common/config.release.h"
 #include "common/define.h"
 
 #define YADECAP_UNUSED [[maybe_unused]]
diff --git a/dataplane/config_values.h b/dataplane/config_values.h
index 31711723..60103499 100644
--- a/dataplane/config_values.h
+++ b/dataplane/config_values.h
@@ -1,10 +1,9 @@
 #pragma once
 
+#include "common/config.release.h"
 #include <cstdint>
 #include <nlohmann/json.hpp>
 
-#include "common/config.h"
-
 struct FragmentationConfig
 {
 	uint64_t size = 1024;
diff --git a/dataplane/controlplane.cpp b/dataplane/controlplane.cpp
index 525bfa4f..2165ac6f 100644
--- a/dataplane/controlplane.cpp
+++ b/dataplane/controlplane.cpp
@@ -9,22 +9,11 @@
 #include <rte_lcore.h>
 #include <rte_malloc.h>
 
-#include "common/fallback.h"
-#include "common/idp.h"
-#include "common/type.h"
-#include "common/version.h"
-
-#include "checksum.h"
 #include "common.h"
-#include "controlplane.h"
+#include "common/version.h"
 #include "dataplane.h"
+#include "dataplane/worker_gc.h"
 #include "debug_latch.h"
-#include "icmp.h"
-#include "icmp_translations.h"
-#include "metadata.h"
-#include "prepare.h"
-#include "worker.h"
-#include "worker_gc.h"
 
 cControlPlane::cControlPlane(cDataPlane* dataPlane) :
         dataPlane(dataPlane),
@@ -273,7 +262,7 @@ common::idp::getSlowWorkerStats::response cControlPlane::SlowWorkerStatsResponse
 
 	for (const auto& [core_id, worker] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 
 		hashtable_gc_stats.emplace_back(worker->socket_id,
 		                                "nat64stateful.lan.state.ht",
@@ -316,9 +305,10 @@ common::idp::get_dregress_counters::response cControlPlane::get_dregress_counter
 {
 	common::dregress::counters_t counters_v4;
 	common::dregress::counters_t counters_v6;
-	for (auto it : dataPlane->slow_workers)
+	for (auto& [core, slow] : dataPlane->slow_workers)
 	{
-		dregress_t& dregress = it.second->Dregress();
+		YANET_GCC_BUG_UNUSED(core);
+		dregress_t& dregress = slow->Dregress();
 		auto guard = dregress.LockCounters();
 		counters_v4.merge(dregress.Counters4());
 		counters_v6.merge(dregress.Counters6());
@@ -336,7 +326,7 @@ common::idp::get_ports_stats::response cControlPlane::get_ports_stats()
 
 	for (const auto& [portId, port] : dataPlane->ports)
 	{
-		(void)port;
+		YANET_GCC_BUG_UNUSED(port);
 
 		rte_eth_stats stats;
 		{
@@ -370,7 +360,7 @@ common::idp::get_ports_stats_extended::response cControlPlane::get_ports_stats_e
 
 	for (const auto& [portId, _] : dataPlane->ports)
 	{
-		(void)_;
+		YANET_GCC_BUG_UNUSED(_);
 
 		auto portStats = dataPlane->getPortStats(portId);
 		response[portId] = portStats;
@@ -414,9 +404,10 @@ common::idp::getControlPlanePortStats::response cControlPlane::getControlPlanePo
 	else
 	{
 		/// all ports
-		for (auto it : dataPlane->slow_workers)
+		for (auto& [core, slow] : dataPlane->slow_workers)
 		{
-			const auto& kni_worker = it.second->KniWorker();
+			YANET_GCC_BUG_UNUSED(core);
+			const auto& kni_worker = slow->KniWorker();
 
 			auto stats = kni_worker.PortsStats().first;
 			for (auto [current, end] = kni_worker.PortsIds(); current != end; ++current, ++stats)
@@ -455,9 +446,10 @@ common::dregress::stats_t cControlPlane::DregressStats() const
 std::optional<std::reference_wrapper<const dataplane::sKniStats>> cControlPlane::KniStats(tPortId pid) const
 {
 	// Dumb iteration over slow workers and their assigned ports, should not be a bottleneck
-	for (auto it : dataPlane->slow_workers)
+	for (auto& [core, slow] : dataPlane->slow_workers)
 	{
-		if (const auto& stats = it.second->KniWorker().PortStats(pid))
+		YANET_GCC_BUG_UNUSED(core);
+		if (const auto& stats = slow->KniWorker().PortStats(pid))
 		{
 			return stats;
 		}
@@ -487,7 +479,7 @@ common::idp::getFWState::response cControlPlane::getFWState()
 
 	for (const auto& [core_id, worker_gc] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 
 		worker_gc->fw_state_mutex.lock();
 		auto fw_state = worker_gc->fw_state;
@@ -532,7 +524,7 @@ common::idp::getFWStateStats::response cControlPlane::getFWStateStats() ///< @to
 
 	for (auto& [socket_id, globalbase_atomics] : dataPlane->globalBaseAtomics)
 	{
-		(void)socket_id;
+		YANET_GCC_BUG_UNUSED(socket_id);
 
 		stats.fwstate4_size = std::max(stats.fwstate4_size, (uint64_t)globalbase_atomics->updater.fw4_state.get_stats().keys_count);
 		stats.fwstate6_size = std::max(stats.fwstate6_size, (uint64_t)globalbase_atomics->updater.fw6_state.get_stats().keys_count);
@@ -545,7 +537,7 @@ eResult cControlPlane::clearFWState()
 {
 	for (auto& [socketId, globalBaseAtomic] : dataPlane->globalBaseAtomics)
 	{
-		(void)socketId;
+		YANET_GCC_BUG_UNUSED(socketId);
 
 		globalBaseAtomic->fw4_state->clear();
 		globalBaseAtomic->fw6_state->clear();
@@ -596,9 +588,9 @@ common::idp::getConfig::response cControlPlane::getConfig() const
 	for (const auto& [port_id, port] : dataPlane->ports)
 	{
 		const auto& [interface_name, rx_queues, tx_queues_count, mac_address, pci, symmetric_mode] = port;
-		(void)rx_queues;
-		(void)tx_queues_count;
-		(void)symmetric_mode;
+		YANET_GCC_BUG_UNUSED(rx_queues);
+		YANET_GCC_BUG_UNUSED(tx_queues_count);
+		YANET_GCC_BUG_UNUSED(symmetric_mode);
 
 		response_ports[port_id] = {interface_name,
 		                           rte_eth_dev_socket_id(port_id),
@@ -713,7 +705,7 @@ common::idp::lpm4LookupAddress::response cControlPlane::lpm4LookupAddress(const
 		const tSocketId& socketId = iter.first;
 		const auto* globalBase = iter.second[dataPlane->currentGlobalBaseId];
 
-		uint32_t valueId;
+		uint32_t valueId = 0;
 		if (globalBase->route_lpm4->lookup(ipAddress, &valueId))
 		{
 			response[socketId] = {true,
@@ -745,7 +737,7 @@ common::idp::lpm6LookupAddress::response cControlPlane::lpm6LookupAddress(const
 		const tSocketId& socketId = iter.first;
 		const auto* globalBase = iter.second[dataPlane->currentGlobalBaseId];
 
-		uint32_t valueId;
+		uint32_t valueId = 0;
 		if (globalBase->route_lpm6->lookup(request, &valueId))
 		{
 			response[socketId] = {true,
@@ -768,7 +760,7 @@ common::idp::samples::response cControlPlane::samples()
 	std::set<common::idp::samples::sample_t> samples;
 	for (auto& [core_id, worker_gc] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 
 		std::lock_guard<std::mutex> guard(worker_gc->samples_mutex);
 
@@ -843,7 +835,7 @@ common::idp::limits::response cControlPlane::limits()
 
 	for (const auto& [core_id, worker_gc] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 		worker_gc->limits(response);
 	}
 
@@ -867,7 +859,7 @@ common::idp::balancer_connection::response cControlPlane::balancer_connection(co
 
 	for (auto& [core_id, worker_gc] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 
 		auto& response_connections = response[worker_gc->socket_id];
 
@@ -931,7 +923,7 @@ common::idp::balancer_connection::response cControlPlane::balancer_connection(co
 					}
 
 					/// @todo: filter_real_port
-					(void)filter_real_port;
+					YANET_GCC_BUG_UNUSED(filter_real_port);
 
 					auto& connections = response_connections[{balancer_id,
 					                                          virtual_ip,
@@ -965,7 +957,7 @@ common::idp::balancer_service_connections::response cControlPlane::balancer_serv
 
 	for (const auto& [core_id, worker_gc] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 
 		auto current_guard = worker_gc->balancer_service_connections.current_lock_guard();
 		response[worker_gc->socket_id] = worker_gc->balancer_service_connections.current();
@@ -980,7 +972,7 @@ common::idp::balancer_real_connections::response cControlPlane::balancer_real_co
 
 	for (const auto& [core_id, worker_gc] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 
 		auto current_guard = worker_gc->balancer_real_connections.current_lock_guard();
 		response[worker_gc->socket_id] = worker_gc->balancer_real_connections.current();
@@ -1083,7 +1075,7 @@ eResult cControlPlane::dump_physical_port(const common::idp::dump_physical_port:
 		/// start dump traffic to interface
 		for (auto& [socket_id, globalbase_atomic] : dataPlane->globalBaseAtomics)
 		{
-			(void)socket_id;
+			YANET_GCC_BUG_UNUSED(socket_id);
 
 			__atomic_or_fetch(&globalbase_atomic->physicalPort_flags[*port_id],
 			                  (uint8_t)(flag),
@@ -1095,7 +1087,7 @@ eResult cControlPlane::dump_physical_port(const common::idp::dump_physical_port:
 		/// stop dump traffic to interface
 		for (auto& [socket_id, globalbase_atomic] : dataPlane->globalBaseAtomics)
 		{
-			(void)socket_id;
+			YANET_GCC_BUG_UNUSED(socket_id);
 
 			__atomic_and_fetch(&globalbase_atomic->physicalPort_flags[*port_id],
 			                   (uint8_t)(~flag),
@@ -1110,7 +1102,7 @@ eResult cControlPlane::balancer_state_clear()
 {
 	for (auto& [core_id, worker_gc] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 		worker_gc->balancer_state_clear();
 	}
 
@@ -1123,7 +1115,7 @@ common::idp::nat64stateful_state::response cControlPlane::nat64stateful_state(co
 
 	for (auto& [core_id, worker_gc] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 		worker_gc->nat64stateful_state(request, response);
 	}
 
@@ -1205,7 +1197,7 @@ void cControlPlane::waitAllWorkers()
 
 	for (const auto& [core_id, worker] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 
 		uint64_t startIteration = worker->iteration;
 		uint64_t nextIteration = startIteration;
diff --git a/dataplane/controlplane.h b/dataplane/controlplane.h
index 17bc2cfe..c981f5c7 100644
--- a/dataplane/controlplane.h
+++ b/dataplane/controlplane.h
@@ -15,14 +15,10 @@
 
 #include "common/idp.h"
 #include "common/result.h"
-#include "common/static_vector.h"
-#include "common/type.h"
 
-#include "dpdk.h"
-#include "dregress.h"
-#include "fragmentation.h"
+#include "dataplane/dregress.h"
+#include "dataplane/kernel_interface_handler.h"
 #include "kernel_interface_handle.h"
-#include "slow_worker.h"
 #include "type.h"
 #include "utils.h"
 
@@ -51,7 +47,7 @@ class cControlPlane ///< @todo: move to cDataPlane
 	eResult updateGlobalBaseBalancer(const common::idp::updateGlobalBaseBalancer::request& request);
 	common::idp::getGlobalBase::response getGlobalBase(const common::idp::getGlobalBase::request& request);
 	common::idp::getWorkerStats::response getWorkerStats(const common::idp::getWorkerStats::request& request);
-	common::slowworker::stats_t SlowWorkerStats() const;
+	[[nodiscard]] common::slowworker::stats_t SlowWorkerStats() const;
 	common::idp::getSlowWorkerStats::response SlowWorkerStatsResponse();
 	common::idp::get_worker_gc_stats::response get_worker_gc_stats();
 	common::idp::get_dregress_counters::response get_dregress_counters();
@@ -59,15 +55,15 @@ class cControlPlane ///< @todo: move to cDataPlane
 	common::idp::get_ports_stats_extended::response get_ports_stats_extended();
 	common::idp::getControlPlanePortStats::response getControlPlanePortStats(const common::idp::getControlPlanePortStats::request& request);
 	common::idp::getPortStatsEx::response getPortStatsEx();
-	common::idp::getFragmentationStats::response getFragmentationStats() const;
-	common::dregress::stats_t DregressStats() const;
-	std::optional<std::reference_wrapper<const dataplane::sKniStats>> KniStats(tPortId) const;
-	dataplane::hashtable_chain_spinlock_stats_t DregressConnectionsStats() const;
-	dregress::LimitsStats DregressLimitsStats() const;
+	[[nodiscard]] common::idp::getFragmentationStats::response getFragmentationStats() const;
+	[[nodiscard]] common::dregress::stats_t DregressStats() const;
+	[[nodiscard]] std::optional<std::reference_wrapper<const dataplane::sKniStats>> KniStats(tPortId) const;
+	[[nodiscard]] dataplane::hashtable_chain_spinlock_stats_t DregressConnectionsStats() const;
+	[[nodiscard]] dregress::LimitsStats DregressLimitsStats() const;
 	common::idp::getFWState::response getFWState();
 	common::idp::getFWStateStats::response getFWStateStats();
 	eResult clearFWState();
-	common::idp::getConfig::response getConfig() const;
+	[[nodiscard]] common::idp::getConfig::response getConfig() const;
 	common::idp::getErrors::response getErrors();
 	common::idp::getReport::response getReport();
 	common::idp::lpm4LookupAddress::response lpm4LookupAddress(const common::idp::lpm4LookupAddress::request& request);
@@ -92,8 +88,8 @@ class cControlPlane ///< @todo: move to cDataPlane
 	virtual void waitAllWorkers();
 
 private:
-	const std::vector<cWorker*>& workers_vector() const;
-	const std::map<tCoreId, dataplane::SlowWorker*>& slow_workers() const;
+	[[nodiscard]] const std::vector<cWorker*>& workers_vector() const;
+	[[nodiscard]] const std::map<tCoreId, dataplane::SlowWorker*>& slow_workers() const;
 
 	template<typename F>
 	// @brief returns sum of results of applying F to all cWorker*s
diff --git a/dataplane/dataplane.cpp b/dataplane/dataplane.cpp
index 41d71f2a..b3d0c28b 100644
--- a/dataplane/dataplane.cpp
+++ b/dataplane/dataplane.cpp
@@ -1,8 +1,8 @@
 #include <arpa/inet.h>
 #include <bitset>
 #include <cstdint>
+#include <cstring>
 #include <limits>
-#include <string.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ -25,19 +25,18 @@
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
-#include <stdio.h>
-#include <stdlib.h>
+#include <cstdio>
+#include <cstdlib>
 #include <sys/mman.h>
 
 #include "common.h"
+#include "common/define.h"
 #include "common/idp.h"
 #include "common/result.h"
 #include "common/tsc_deltas.h"
 #include "dataplane.h"
-#include "debug_latch.h"
+#include "dataplane/sdpserver.h"
 #include "globalbase.h"
-#include "lpm.h"
-#include "report.h"
 #include "sock_dev.h"
 #include "work_runner.h"
 #include "worker.h"
@@ -67,9 +66,10 @@ cDataPlane::~cDataPlane()
 	{
 		rte_mempool_free(mempool_log);
 	}
-	for (auto it : socket_cplane_mempools)
+	for (auto& [socket_id, rte_mempool] : socket_cplane_mempools)
 	{
-		rte_mempool_free(it.second);
+		YANET_GCC_BUG_UNUSED(socket_id);
+		rte_mempool_free(rte_mempool);
 	}
 }
 
@@ -131,7 +131,7 @@ eResult cDataPlane::init(const std::string& binaryPath,
 		}
 	}
 
-	mempool_log = rte_mempool_create("log", YANET_CONFIG_SAMPLES_SIZE, sizeof(samples::sample_t), 0, 0, NULL, NULL, NULL, NULL, SOCKET_ID_ANY, MEMPOOL_F_NO_IOVA_CONTIG);
+	mempool_log = rte_mempool_create("log", YANET_CONFIG_SAMPLES_SIZE, sizeof(samples::sample_t), 0, 0, nullptr, nullptr, nullptr, nullptr, SOCKET_ID_ANY, MEMPOOL_F_NO_IOVA_CONTIG);
 
 	result = initGlobalBases();
 	if (result != eResult::success)
@@ -233,7 +233,7 @@ eResult cDataPlane::init(const std::string& binaryPath,
 
 		for (const auto& [core_id, worker_gc] : worker_gcs)
 		{
-			(void)core_id;
+			YANET_GCC_BUG_UNUSED(core_id);
 			gc_sockets_used.emplace(worker_gc->socket_id);
 		}
 
@@ -485,9 +485,9 @@ eResult cDataPlane::initPorts()
 	{
 		const std::string& interfaceName = configPortIter.first;
 		const auto& [pci, name, symmetric_mode, rss_flags] = configPortIter.second;
-		(void)pci;
+		YANET_GCC_BUG_UNUSED(pci);
 
-		tPortId portId;
+		tPortId portId = 0;
 
 		if (StartsWith(name, SOCK_DEV_PREFIX))
 		{
@@ -938,8 +938,8 @@ eResult cDataPlane::initWorkers()
 		for (const auto& [port_id, port] : ports)
 		{
 			const auto& [interface_name, rx_queues, tx_queues_count, mac_address, pci, symmetric_mode] = port;
-			(void)mac_address;
-			(void)pci;
+			YANET_GCC_BUG_UNUSED(mac_address);
+			YANET_GCC_BUG_UNUSED(pci);
 
 			if (!basePermanently.ports.Register(port_id))
 				return eResult::invalidPortsCount;
@@ -1037,7 +1037,7 @@ eResult cDataPlane::initWorkers()
 	worker_gc_t::PortToSocketArray port_to_socket;
 	for (const auto& [port_id, port] : ports)
 	{
-		(void)port;
+		YANET_GCC_BUG_UNUSED(port);
 		port_to_socket[port_id] = rte_eth_dev_socket_id(port_id);
 	}
 
@@ -1378,7 +1378,7 @@ void cDataPlane::init_worker_base()
 
 	for (auto& [core_id, worker] : worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 
 		auto* base = &worker->bases[worker->current_base_id];
 		auto* base_next = &worker->bases[worker->current_base_id ^ 1];
@@ -1401,7 +1401,7 @@ void cDataPlane::timestamp_thread()
 		{
 			for (const auto& [socket_id, globalbase_atomic] : globalBaseAtomics)
 			{
-				(void)socket_id;
+				YANET_GCC_BUG_UNUSED(socket_id);
 				globalbase_atomic->currentTime = current_time;
 			}
 
@@ -1431,9 +1431,10 @@ void cDataPlane::SWRateLimiterTimeTracker()
 				__atomic_store_n(&worker->packetsToSWNPRemainder, config.SWNormalPriorityRateLimitPerWorker, __ATOMIC_RELAXED);
 			}
 
-			for (auto it : slow_workers)
+			for (auto& [core, slow] : slow_workers)
 			{
-				it.second->ResetIcmpOutRemainder(config.SWICMPOutRateLimit / config.rateLimitDivisor);
+				YANET_GCC_BUG_UNUSED(core);
+				slow->ResetIcmpOutRemainder(config.SWICMPOutRateLimit / config.rateLimitDivisor);
 			}
 
 			prevTimePointForSWRateLimiter = curTimePointForSWRateLimiter;
@@ -1660,9 +1661,9 @@ eResult cDataPlane::allocateSharedMemory()
 		int shmid = shmget(key, 0, 0);
 		if (shmid != -1)
 		{
-			if (shmctl(shmid, IPC_RMID, NULL) < 0)
+			if (shmctl(shmid, IPC_RMID, nullptr) < 0)
 			{
-				YADECAP_LOG_ERROR("shmctl(%d, IPC_RMID, NULL): %s\n", shmid, strerror(errno));
+				YADECAP_LOG_ERROR("shmctl(%d, IPC_RMID, nullptr): %s\n", shmid, strerror(errno));
 				return eResult::errorInitSharedMemory;
 			}
 		}
@@ -1680,10 +1681,10 @@ eResult cDataPlane::allocateSharedMemory()
 			return eResult::errorInitSharedMemory;
 		}
 
-		void* shmaddr = shmat(shmid, NULL, 0);
+		void* shmaddr = shmat(shmid, nullptr, 0);
 		if (shmaddr == (void*)-1)
 		{
-			YADECAP_LOG_ERROR("shmat(%d, NULL, %d): %s\n", shmid, 0, strerror(errno));
+			YADECAP_LOG_ERROR("shmat(%d, nullptr, %d): %s\n", shmid, 0, strerror(errno));
 			return eResult::errorInitSharedMemory;
 		}
 
@@ -1767,8 +1768,9 @@ eResult cDataPlane::splitSharedMemoryPerWorkers()
 		const auto& [key, shm] = it->second;
 
 		auto offset = offsets[shm];
-		worker->tsc_deltas = (dataplane::perf::tsc_deltas*)((intptr_t)shm + offset);
-		memset(worker->tsc_deltas, 0, sizeof(dataplane::perf::tsc_deltas));
+		worker->tsc_deltas = reinterpret_cast<dataplane::perf::tsc_deltas*>(reinterpret_cast<intptr_t>(shm) + offset);
+		// Use value-initialization to reset the object
+		*worker->tsc_deltas = {};
 		offsets[shm] += sizeof(dataplane::perf::tsc_deltas);
 
 		auto meta = common::idp::get_shm_tsc_info::tsc_meta(worker->coreId, socket_id, key, offset);
@@ -1898,7 +1900,7 @@ void cDataPlane::switch_worker_base()
 
 	for (auto& [core_id, worker] : worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 
 		auto* base_next = &worker->bases[worker->current_base_id ^ 1];
 		base_nexts.emplace_back(worker->socket_id, base_next);
@@ -2164,9 +2166,10 @@ nlohmann::json cDataPlane::makeLegacyControlPlaneWorkerConfig()
 const std::set<tCoreId> cDataPlane::FastWorkerCores() const
 {
 	std::set<tCoreId> cores;
-	for (auto it : config.workers)
+	for (auto& [core, workers] : config.workers)
 	{
-		if (!cores.insert(it.first).second)
+		YANET_GCC_BUG_UNUSED(workers);
+		if (!cores.insert(core).second)
 		{
 			YANET_LOG_ERROR("Same core specified in config for multiple workers\n");
 		}
@@ -2288,9 +2291,9 @@ eResult cDataPlane::checkConfig()
 		for (const auto& portIter : config.ports)
 		{
 			const auto& [pci, name, symmetric_mode, rss_flags] = portIter.second;
-			(void)pci;
-			(void)symmetric_mode;
-			(void)rss_flags;
+			YANET_GCC_BUG_UNUSED(pci);
+			YANET_GCC_BUG_UNUSED(symmetric_mode);
+			YANET_GCC_BUG_UNUSED(rss_flags);
 
 			if (exist(names, name))
 			{
@@ -2388,9 +2391,9 @@ eResult cDataPlane::initEal(const std::string& binaryPath,
 	for (const auto& port : config.ports)
 	{
 		const auto& [pci, name, symmetric_mode, rss_flags] = port.second;
-		(void)name;
-		(void)symmetric_mode;
-		(void)rss_flags;
+		YANET_GCC_BUG_UNUSED(name);
+		YANET_GCC_BUG_UNUSED(symmetric_mode);
+		YANET_GCC_BUG_UNUSED(rss_flags);
 
 		// Do not whitelist sock dev virtual devices
 		if (StartsWith(name, SOCK_DEV_PREFIX))
diff --git a/dataplane/dataplane.h b/dataplane/dataplane.h
index e11b0f87..8b05af2d 100644
--- a/dataplane/dataplane.h
+++ b/dataplane/dataplane.h
@@ -26,7 +26,6 @@
 #include "memory_manager.h"
 #include "neighbor.h"
 #include "report.h"
-#include "sdpserver.h"
 #include "slow_worker.h"
 #include "type.h"
 
diff --git a/dataplane/dpdk.cpp b/dataplane/dpdk.cpp
index 2d05d4f5..c799536d 100644
--- a/dataplane/dpdk.cpp
+++ b/dataplane/dpdk.cpp
@@ -16,7 +16,7 @@ std::optional<std::string> GetNameByPort(tPortId pid)
 
 std::optional<tPortId> GetPortByName(const std::string& name)
 {
-	tPortId port;
+	tPortId port = 0;
 	if (int res = rte_eth_dev_get_port_by_name(name.c_str(), &port); res)
 	{
 		YANET_LOG_ERROR("Failed to get port for name %s (%s)\n", name.c_str(), strerror(res));
@@ -36,4 +36,4 @@ std::optional<common::mac_address_t> GetMacAddress(tPortId pid)
 	return std::optional<common::mac_address_t>{ether_addr.addr_bytes};
 }
 
-}
\ No newline at end of file
+}
diff --git a/dataplane/dregress.cpp b/dataplane/dregress.cpp
index 0da1b766..c833aa01 100644
--- a/dataplane/dregress.cpp
+++ b/dataplane/dregress.cpp
@@ -1,8 +1,6 @@
 #include <rte_tcp.h>
 #include <rte_udp.h>
 
-#include "common/fallback.h"
-
 #include "checksum.h"
 #include "dataplane.h"
 #include "dregress.h"
@@ -115,11 +113,11 @@ void dregress_t::insert(rte_mbuf* mbuf)
 		}
 
 		const auto& [prefix, nexthop, is_best, label, community, peer_as, origin_as] = *direction;
-		(void)prefix;
-		(void)is_best;
-		(void)community;
-		(void)peer_as;
-		(void)origin_as;
+		YANET_GCC_BUG_UNUSED(prefix);
+		YANET_GCC_BUG_UNUSED(is_best);
+		YANET_GCC_BUG_UNUSED(community);
+		YANET_GCC_BUG_UNUSED(peer_as);
+		YANET_GCC_BUG_UNUSED(origin_as);
 
 		labelled_nexthop = ipv6_address_t::convert(nexthop);
 		labelled_label = label;
@@ -128,13 +126,13 @@ void dregress_t::insert(rte_mbuf* mbuf)
 	}
 	else
 	{
-		dregress::connection_value_t* value;
-		dataplane::spinlock_t* locker;
+		dregress::connection_value_t* value = nullptr;
+		dataplane::spinlock_t* locker = nullptr;
 
 		connections->lookup(key, value, locker);
 
-		uint32_t loss_count;
-		uint32_t ack_count;
+		uint32_t loss_count = 0;
+		uint32_t ack_count = 0;
 
 		int32_t ack_diff = 0;
 		int32_t loss_diff = 0;
@@ -158,7 +156,7 @@ void dregress_t::insert(rte_mbuf* mbuf)
 			labelled_label = label;
 
 			ipv6_address_t prefix_address;
-			uint8_t prefix_mask;
+			uint8_t prefix_mask = 0;
 			if (prefix.is_ipv4())
 			{
 				prefix_address = ipv6_address_t::convert(prefix.get_ipv4().address());
@@ -334,7 +332,7 @@ void dregress_t::insert(rte_mbuf* mbuf)
 		}
 	}
 
-	uint16_t payload_length;
+	uint16_t payload_length = 0;
 	if (metadata->network_headerType == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4))
 	{
 		rte_ipv4_hdr* ipv4HeaderInner = rte_pktmbuf_mtod_offset(mbuf, rte_ipv4_hdr*, metadata->network_headerOffset);
@@ -545,11 +543,11 @@ std::optional<dregress::direction_t> dregress_t::lookup(rte_mbuf* mbuf)
 	auto direction = (*std::next(directions.begin(), rand() % directions.size())).second;
 	{
 		auto& [prefix, nexthop, is_best, label, community, peer_as, origin_as] = direction;
-		(void)nexthop;
-		(void)label;
-		(void)community;
-		(void)peer_as;
-		(void)origin_as;
+		YANET_GCC_BUG_UNUSED(nexthop);
+		YANET_GCC_BUG_UNUSED(label);
+		YANET_GCC_BUG_UNUSED(community);
+		YANET_GCC_BUG_UNUSED(peer_as);
+		YANET_GCC_BUG_UNUSED(origin_as);
 
 		if (prefix.mask() != mask_max)
 		{
diff --git a/dataplane/dregress.h b/dataplane/dregress.h
index 9a7b68ed..956f8aca 100644
--- a/dataplane/dregress.h
+++ b/dataplane/dregress.h
@@ -3,7 +3,6 @@
 #include <mutex>
 
 #include "common/btree.h"
-#include "common/idp.h"
 #include "common/type.h"
 
 #include "hashtable.h"
diff --git a/dataplane/dynamic_table.h b/dataplane/dynamic_table.h
index 5bfb1e01..ce2e50e5 100644
--- a/dataplane/dynamic_table.h
+++ b/dataplane/dynamic_table.h
@@ -1,8 +1,6 @@
 #pragma once
 
-#include <cinttypes>
-
-#include "common/config.h"
+#include "common/config.release.h"
 #include "common/define.h"
 #include "common/result.h"
 
@@ -35,10 +33,7 @@ class dynamic_table
 	}
 
 public:
-	dynamic_table() :
-	        width_bits(0)
-	{
-	}
+	dynamic_table() = default;
 
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
 	inline void lookup(const uint32_t (&k1s)[burst_size],
@@ -97,7 +92,7 @@ class dynamic_table
 	}
 
 protected:
-	uint32_t width_bits;
+	uint32_t width_bits{};
 	value_t values[];
 };
 
diff --git a/dataplane/flat.h b/dataplane/flat.h
index 5ff7c373..42f8c2ea 100644
--- a/dataplane/flat.h
+++ b/dataplane/flat.h
@@ -1,7 +1,5 @@
 #pragma once
 
-#include <cinttypes>
-
 #include <vector>
 
 #include "common/define.h"
diff --git a/dataplane/fragmentation.cpp b/dataplane/fragmentation.cpp
index 599b2a3c..8cf1ec65 100644
--- a/dataplane/fragmentation.cpp
+++ b/dataplane/fragmentation.cpp
@@ -25,14 +25,14 @@ Fragmentation::~Fragmentation()
 {
 	for (const auto& [key, value] : fragments_)
 	{
-		(void)key;
+		YANET_GCC_BUG_UNUSED(key);
 
 		for (const auto& [range_from, range_value] : std::get<0>(value))
 		{
-			(void)range_from;
+			YANET_GCC_BUG_UNUSED(range_from);
 
 			const auto& [range_to, mbuf] = range_value;
-			(void)range_to;
+			YANET_GCC_BUG_UNUSED(range_to);
 
 			rte_pktmbuf_free(mbuf);
 		}
@@ -217,10 +217,10 @@ void Fragmentation::handle()
 
 			for (auto& [range_from, range_value] : std::get<0>(value))
 			{
-				(void)range_from;
+				YANET_GCC_BUG_UNUSED(range_from);
 
 				const auto& [range_to, mbuf] = range_value;
-				(void)range_to;
+				YANET_GCC_BUG_UNUSED(range_to);
 
 				dataplane::metadata* metadata = YADECAP_METADATA(mbuf);
 				metadata->flow.data = firstPacket_metadata->flow.data;
@@ -238,10 +238,10 @@ void Fragmentation::handle()
 	{
 		for (auto& [range_from, range_value] : std::get<0>(fragments_[key]))
 		{
-			(void)range_from;
+			YANET_GCC_BUG_UNUSED(range_from);
 
 			const auto& [range_to, mbuf] = range_value;
-			(void)range_to;
+			YANET_GCC_BUG_UNUSED(range_to);
 
 			stats_.timeout_packets++;
 			rte_pktmbuf_free(mbuf);
@@ -276,7 +276,7 @@ bool Fragmentation::isCollected(const fragmentation::value_t& value) const
 	for (const auto& [range_from, range_value] : std::get<0>(value))
 	{
 		const auto& [range_to, mbuf] = range_value;
-		(void)mbuf;
+		YANET_GCC_BUG_UNUSED(mbuf);
 
 		if (range_from != next_range_from)
 		{
@@ -301,7 +301,7 @@ bool Fragmentation::isIntersect(const fragmentation::value_t& value,
 	for (const auto& [range_from, range_value] : std::get<0>(value))
 	{
 		const auto& [range_to, mbuf] = range_value;
-		(void)mbuf;
+		YANET_GCC_BUG_UNUSED(mbuf);
 
 		if (second_range_to < range_from)
 		{
diff --git a/dataplane/fragmentation.h b/dataplane/fragmentation.h
index e25070e2..ec4459bd 100644
--- a/dataplane/fragmentation.h
+++ b/dataplane/fragmentation.h
@@ -1,9 +1,5 @@
 #pragma once
 
-#include <cinttypes>
-
-#include <atomic>
-#include <map>
 #include <tuple>
 #include <variant>
 
@@ -50,7 +46,7 @@ class Fragmentation
 	Fragmentation& operator=(Fragmentation&& other) = default;
 
 public:
-	common::fragmentation::stats_t getStats() const;
+	[[nodiscard]] common::fragmentation::stats_t getStats() const;
 	OnCollected& Callback() { return callback_; }
 	void Configure(const FragmentationConfig& cfg) { config_ = cfg; }
 
@@ -58,9 +54,9 @@ class Fragmentation
 	void handle();
 
 protected:
-	bool isTimeout(const value_t& value) const;
-	bool isCollected(const value_t& value) const;
-	bool isIntersect(const value_t& value, const uint32_t& range_from, const uint32_t& range_to) const;
+	[[nodiscard]] bool isTimeout(const value_t& value) const;
+	[[nodiscard]] bool isCollected(const value_t& value) const;
+	[[nodiscard]] bool isIntersect(const value_t& value, const uint32_t& range_from, const uint32_t& range_to) const;
 
 protected:
 	OnCollected callback_;
@@ -72,4 +68,4 @@ class Fragmentation
 	std::map<key_t, value_t> fragments_;
 };
 
-} // namespace fragmentation
\ No newline at end of file
+} // namespace fragmentation
diff --git a/dataplane/globalbase.cpp b/dataplane/globalbase.cpp
index 3bb61b86..e199c004 100644
--- a/dataplane/globalbase.cpp
+++ b/dataplane/globalbase.cpp
@@ -18,7 +18,7 @@ using namespace dataplane::globalBase;
 atomic::atomic(cDataPlane* dataPlane,
                const tSocketId& socketId) :
         dataPlane(dataPlane),
-        socketId(socketId)
+        socketId(socketId), tsc_active_state(dataPlane->getConfigValues().tsc_active_state)
 {
 	fw_state_config.tcp_timeout = dataPlane->getConfigValues().stateful_firewall_tcp_timeout;
 	fw_state_config.udp_timeout = dataPlane->getConfigValues().stateful_firewall_udp_timeout;
@@ -28,12 +28,6 @@ atomic::atomic(cDataPlane* dataPlane,
 	memset(physicalPort_flags, 0, sizeof(physicalPort_flags));
 	memset(counter_shifts, 0, sizeof(counter_shifts));
 	memset(gc_counter_shifts, 0, sizeof(gc_counter_shifts));
-
-	tsc_active_state = dataPlane->getConfigValues().tsc_active_state;
-}
-
-atomic::~atomic()
-{
 }
 
 generation::generation(cDataPlane* dataPlane,
@@ -50,10 +44,6 @@ generation::generation(cDataPlane* dataPlane,
 	          balancer_real_state_t());
 }
 
-generation::~generation()
-{
-}
-
 eResult generation::init()
 {
 	eResult result = eResult::success;
@@ -551,53 +541,39 @@ eResult generation::get(const common::idp::getGlobalBase::request& request,
 
 eResult generation::clear()
 {
-	for (unsigned int logicalPortId = 0;
-	     logicalPortId < CONFIG_YADECAP_LOGICALPORTS_SIZE;
-	     logicalPortId++)
+	for (auto& logicalPort : logicalPorts)
 	{
-		logicalPorts[logicalPortId] = dataplane::globalBase::tLogicalPort();
+		logicalPort = dataplane::globalBase::tLogicalPort();
 	}
 
-	for (tun64_id_t tun64Id = 0;
-	     tun64Id < CONFIG_YADECAP_TUN64_SIZE;
-	     tun64Id++)
+	for (auto& tun64tunnel : tun64tunnels)
 	{
-		tun64tunnels[tun64Id] = dataplane::globalBase::tun64_t();
+		tun64tunnel = dataplane::globalBase::tun64_t();
 	}
 
-	for (unsigned int decapId = 0;
-	     decapId < CONFIG_YADECAP_DECAPS_SIZE;
-	     decapId++)
+	for (auto& decap : decaps)
 	{
-		decaps[decapId] = dataplane::globalBase::tDecap();
+		decap = dataplane::globalBase::tDecap();
 	}
 
-	for (unsigned int interfaceId = 0;
-	     interfaceId < CONFIG_YADECAP_INTERFACES_SIZE;
-	     interfaceId++)
+	for (auto& interface : interfaces)
 	{
-		interfaces[interfaceId] = dataplane::globalBase::tInterface();
+		interface = dataplane::globalBase::tInterface();
 	}
 
-	for (unsigned int nat64statefulId = 0;
-	     nat64statefulId < YANET_CONFIG_NAT64STATEFULS_SIZE;
-	     nat64statefulId++)
+	for (auto& nat64stateful : nat64statefuls)
 	{
-		nat64statefuls[nat64statefulId] = dataplane::globalBase::nat64stateful_t();
+		nat64stateful = dataplane::globalBase::nat64stateful_t();
 	}
 
-	for (unsigned int nat64statelessId = 0;
-	     nat64statelessId < CONFIG_YADECAP_NAT64STATELESSES_SIZE;
-	     nat64statelessId++)
+	for (auto& nat64statelesse : nat64statelesses)
 	{
-		nat64statelesses[nat64statelessId] = dataplane::globalBase::tNat64stateless();
+		nat64statelesse = dataplane::globalBase::tNat64stateless();
 	}
 
-	for (unsigned int balancer_id = 0;
-	     balancer_id < YANET_CONFIG_BALANCERS_SIZE;
-	     balancer_id++)
+	for (auto& balancer : balancers)
 	{
-		balancers[balancer_id] = dataplane::globalBase::balancer_t();
+		balancer = dataplane::globalBase::balancer_t();
 	}
 
 	tun64_enabled = 0;
@@ -612,11 +588,9 @@ eResult generation::clear()
 
 	tun64mappingsTable.clear();
 
-	for (unsigned int fw_state_sync_config_id = 0;
-	     fw_state_sync_config_id < CONFIG_YADECAP_ACLS_SIZE;
-	     fw_state_sync_config_id++)
+	for (auto& fw_state_sync_config : fw_state_sync_configs)
 	{
-		fw_state_sync_configs[fw_state_sync_config_id] = fw_state_sync_config_t{};
+		fw_state_sync_config = fw_state_sync_config_t{};
 	}
 
 	// NOTE: we don't explicitly clear current fw states, as there might be responding packets.
@@ -1544,7 +1518,7 @@ eResult generation::update_balancer_services(const common::idp::updateGlobalBase
 				}
 				for (const auto& [core_id, worker_gc] : dataPlane->worker_gcs)
 				{
-					(void)core_id;
+					YANET_GCC_BUG_UNUSED(core_id);
 					sum_gc += worker_gc->counters[counter_id + i];
 				}
 				for (const auto& item : dataPlane->globalBaseAtomics)
@@ -1636,7 +1610,7 @@ inline uint64_t generation::count_real_connections(uint32_t counter_id)
 	uint64_t sessions_destroyed_gc = 0;
 	for (const auto& [node_id, worker_gc] : dataPlane->worker_gcs)
 	{
-		(void)node_id;
+		YANET_GCC_BUG_UNUSED(node_id);
 		sessions_created_gc += worker_gc->counters[counter_id + (tCounterId)::balancer::gc_real_counter::sessions_created];
 		sessions_destroyed_gc += worker_gc->counters[counter_id + (tCounterId)::balancer::gc_real_counter::sessions_destroyed];
 	}
@@ -2342,9 +2316,10 @@ eResult generation::dregress_prefix_update(const common::idp::updateGlobalBase::
 {
 	eResult result = eResult::success;
 
-	for (auto it : dataPlane->slow_workers)
+	for (auto& [core, slow] : dataPlane->slow_workers)
 	{
-		::dregress_t& dregress = it.second->Dregress();
+		YANET_GCC_BUG_UNUSED(core);
+		::dregress_t& dregress = slow->Dregress();
 		for (const auto& [prefix, value_id] : request)
 		{
 			std::lock_guard<std::mutex> guard(dregress.prefixes_mutex);
@@ -2359,9 +2334,10 @@ eResult generation::dregress_prefix_remove(const common::idp::updateGlobalBase::
 {
 	eResult result = eResult::success;
 
-	for (auto it : dataPlane->slow_workers)
+	for (auto& [core, slow] : dataPlane->slow_workers)
 	{
-		::dregress_t& dregress = it.second->Dregress();
+		YANET_GCC_BUG_UNUSED(core);
+		::dregress_t& dregress = slow->Dregress();
 		for (const auto& prefix : request)
 		{
 			std::lock_guard<std::mutex> guard(dregress.prefixes_mutex);
@@ -2375,9 +2351,10 @@ eResult generation::dregress_prefix_clear()
 {
 	eResult result = eResult::success;
 
-	for (auto it : dataPlane->slow_workers)
+	for (auto& [core, slow] : dataPlane->slow_workers)
 	{
-		::dregress_t& dregress = it.second->Dregress();
+		YANET_GCC_BUG_UNUSED(core);
+		::dregress_t& dregress = slow->Dregress();
 		std::lock_guard<std::mutex> guard(dregress.prefixes_mutex);
 		dregress.prefixes.clear();
 	}
@@ -2389,9 +2366,10 @@ eResult generation::dregress_local_prefix_update(const common::idp::updateGlobal
 {
 	eResult result = eResult::success;
 
-	for (auto it : dataPlane->slow_workers)
+	for (auto& [core, slow] : dataPlane->slow_workers)
 	{
-		::dregress_t& dregress = it.second->Dregress();
+		YANET_GCC_BUG_UNUSED(core);
+		::dregress_t& dregress = slow->Dregress();
 		std::lock_guard<std::mutex> guard(dregress.prefixes_mutex);
 
 		dregress.local_prefixes_v4.clear();
@@ -2416,9 +2394,10 @@ eResult generation::dregress_value_update(const common::idp::updateGlobalBase::d
 {
 	eResult result = eResult::success;
 
-	for (auto it : dataPlane->slow_workers)
+	for (auto& [core, slow] : dataPlane->slow_workers)
 	{
-		::dregress_t& dregress = it.second->Dregress();
+		YANET_GCC_BUG_UNUSED(core);
+		::dregress_t& dregress = slow->Dregress();
 		std::lock_guard<std::mutex> guard(dregress.prefixes_mutex);
 
 		for (const auto& [value_id, value] : request)
diff --git a/dataplane/globalbase.h b/dataplane/globalbase.h
index 1f7aaca7..fbb38538 100644
--- a/dataplane/globalbase.h
+++ b/dataplane/globalbase.h
@@ -88,7 +88,7 @@ class atomic
 {
 public:
 	atomic(cDataPlane* dataPlane, const tSocketId& socketId);
-	~atomic();
+	~atomic() = default;
 
 public: ///< @todo
 	cDataPlane* dataPlane;
@@ -134,7 +134,7 @@ class generation
 {
 public:
 	generation(cDataPlane* dataPlane, const tSocketId& socketId);
-	~generation();
+	~generation() = default;
 
 public:
 	eResult init();
diff --git a/dataplane/hashtable.h b/dataplane/hashtable.h
index 1d51edd0..a41de272 100644
--- a/dataplane/hashtable.h
+++ b/dataplane/hashtable.h
@@ -62,7 +62,7 @@ inline uint32_t calculate_hash_crc(const key_t& key)
 template<typename key_t>
 inline uint32_t calculate_hash_murmur3(const key_t& key)
 {
-	uint32_t result;
+	uint32_t result = 0;
 	MurmurHash3_x86_32(&key, sizeof(key), 19, &result);
 	return result;
 }
@@ -82,14 +82,14 @@ class spinlock_t final
 	}
 
 public:
-	inline void lock()
+	void lock()
 	{
 		YADECAP_MEMORY_BARRIER_COMPILE;
 		rte_spinlock_recursive_lock(&locker);
 		YADECAP_MEMORY_BARRIER_COMPILE;
 	}
 
-	inline void unlock()
+	void unlock()
 	{
 		YADECAP_MEMORY_BARRIER_COMPILE;
 		rte_spinlock_recursive_unlock(&locker);
@@ -111,12 +111,12 @@ class spinlock_nonrecursive_t final
 	}
 
 public:
-	inline void lock()
+	void lock()
 	{
 		rte_spinlock_lock(&locker);
 	}
 
-	inline void unlock()
+	void unlock()
 	{
 		rte_spinlock_unlock(&locker);
 	}
@@ -129,16 +129,9 @@ class spinlock_nonrecursive_t final
 
 struct hashtable_gc_t
 {
-	hashtable_gc_t() :
-	        offset(0),
-	        valid_keys(0),
-	        iterations(0)
-	{
-	}
-
-	uint32_t offset;
-	uint64_t valid_keys;
-	uint64_t iterations;
+	uint32_t offset{};
+	uint64_t valid_keys{};
+	uint64_t iterations{};
 };
 
 template<typename TKey,
@@ -166,9 +159,9 @@ class hashtable_chain_t
 	constexpr static uint64_t keysSize = size_T * pairsPerChunk_T + extendedSize_T * pairsPerExtendedChunk_T;
 
 public:
-	inline void lookup(const TKey* keys,
-	                   TValue** values,
-	                   const unsigned int& count)
+	void lookup(const TKey* keys,
+	            TValue** values,
+	            const unsigned int& count)
 	{
 		for (unsigned int key_i = 0;
 		     key_i < count;
@@ -229,8 +222,8 @@ class hashtable_chain_t
 		}
 	}
 
-	inline bool lookup(const TKey& key,
-	                   TValue*& value) const
+	bool lookup(const TKey& key,
+	            TValue*& value) const
 	{
 		lookup(&key, &value, 1);
 		return (value != nullptr);
@@ -416,7 +409,7 @@ class hashtable_chain_t
 		}
 
 	public:
-		inline uint32_t getNextExtendedChunkId() const
+		[[nodiscard]] uint32_t getNextExtendedChunkId() const
 		{
 			return nextExtendedChunkId & 0x00FFFFFFu;
 		}
@@ -426,7 +419,7 @@ class hashtable_chain_t
 			nextExtendedChunkId = (nextExtendedChunkId & 0xFF000000u) | (extendedChunkId & 0x00FFFFFFu);
 		}
 
-		inline bool isValid(const unsigned int& key_i) const
+		[[nodiscard]] bool isValid(const unsigned int& key_i) const
 		{
 			return keyValids & (1 << key_i);
 		}
@@ -443,22 +436,22 @@ class hashtable_chain_t
 			YADECAP_MEMORY_BARRIER_COMPILE;
 		}
 
-		inline const TKey& getKey(unsigned int key_i) const
+		const TKey& getKey(unsigned int key_i) const
 		{
 			return pairs[key_i].key;
 		}
 
-		inline TKey& getKey(unsigned int key_i)
+		TKey& getKey(unsigned int key_i)
 		{
 			return pairs[key_i].key;
 		}
 
-		inline const TValue& getValue(unsigned int key_i) const
+		const TValue& getValue(unsigned int key_i) const
 		{
 			return pairs[key_i].value;
 		}
 
-		inline TValue& getValue(unsigned int key_i)
+		TValue& getValue(unsigned int key_i)
 		{
 			return pairs[key_i].value;
 		}
@@ -492,7 +485,7 @@ class hashtable_chain_t
 		}
 
 	public:
-		inline uint32_t getNextExtendedChunkId() const
+		[[nodiscard]] uint32_t getNextExtendedChunkId() const
 		{
 			return nextExtendedChunkId & 0x00FFFFFFu;
 		}
@@ -502,7 +495,7 @@ class hashtable_chain_t
 			nextExtendedChunkId = (nextExtendedChunkId & 0xFF000000u) | (extendedChunkId & 0x00FFFFFFu);
 		}
 
-		inline bool isValid(const unsigned int& key_i) const
+		[[nodiscard]] bool isValid(const unsigned int& key_i) const
 		{
 			return keyValids & (1 << key_i);
 		}
@@ -519,22 +512,22 @@ class hashtable_chain_t
 			YADECAP_MEMORY_BARRIER_COMPILE;
 		}
 
-		inline const TKey& getKey(unsigned int key_i) const
+		const TKey& getKey(unsigned int key_i) const
 		{
 			return pairs[key_i].key;
 		}
 
-		inline TKey& getKey(unsigned int key_i)
+		TKey& getKey(unsigned int key_i)
 		{
 			return pairs[key_i].key;
 		}
 
-		inline const TValue& getValue(unsigned int key_i) const
+		const TValue& getValue(unsigned int key_i) const
 		{
 			return pairs[key_i].value;
 		}
 
-		inline TValue& getValue(unsigned int key_i)
+		TValue& getValue(unsigned int key_i)
 		{
 			return pairs[key_i].value;
 		}
@@ -559,8 +552,8 @@ class hashtable_chain_t
 	};
 
 protected:
-	static inline bool compareKeys(const TKey& first,
-	                               const TKey& second)
+	static bool compareKeys(const TKey& first,
+	                        const TKey& second)
 	{
 		return !memcmp(&first, &second, sizeof(TKey));
 	}
@@ -649,8 +642,7 @@ class hashtable_chain_spinlock_t
 	using hashtable_t = hashtable_chain_spinlock_t<key_T, value_T, size_T, extendedSize_T, pairsPerChunk_T, pairsPerExtendedChunk_T>;
 
 public:
-	hashtable_chain_spinlock_t() :
-	        gcIndex(0)
+	hashtable_chain_spinlock_t()
 	{
 		for (uint32_t id = 0; id < extendedSize_T - 1; ++id)
 		{
@@ -667,9 +659,9 @@ class hashtable_chain_spinlock_t
 	constexpr static uint64_t keysSize = size_T * pairsPerChunk_T + extendedSize_T * pairsPerExtendedChunk_T;
 
 public:
-	inline void lookup(const key_T& key,
-	                   value_T*& value,
-	                   spinlock_t*& locker)
+	void lookup(const key_T& key,
+	            value_T*& value,
+	            spinlock_t*& locker)
 	{
 		const uint32_t hash = rte_hash_crc(&key, sizeof(key_T), 0);
 		auto& chunk = chunks[hash & (size_T - 1)];
@@ -717,8 +709,8 @@ class hashtable_chain_spinlock_t
 		locker->unlock();
 	}
 
-	inline bool insert(const key_T& key,
-	                   const value_T& value)
+	bool insert(const key_T& key,
+	            const value_T& value)
 	{
 		value_T* chunk_value{nullptr};
 		spinlock_t* locker{nullptr};
@@ -742,7 +734,7 @@ class hashtable_chain_spinlock_t
 	///
 	/// Returns "false" when the table is full, in this case the lock is
 	/// automatically unlocked.
-	inline eResult get(const key_T& key, value_T*& value, spinlock_t*& locker)
+	eResult get(const key_T& key, value_T*& value, spinlock_t*& locker)
 
 	{
 		const uint32_t hash = rte_hash_crc(&key, sizeof(key_T), 0);
@@ -859,7 +851,7 @@ class hashtable_chain_spinlock_t
 		return eResult::isFull;
 	}
 
-	inline bool remove(const key_T& key)
+	bool remove(const key_T& key)
 	{
 		const uint32_t hash = rte_hash_crc(&key, sizeof(key_T), 0);
 		auto& chunk = chunks[hash & (size_T - 1)];
@@ -1166,8 +1158,7 @@ class hashtable_chain_spinlock_t
 			iterator_t(hashtable_t* hashtable,
 			           const uint32_t& chunk_i) :
 			        hashtable(hashtable),
-			        chunk_i(chunk_i),
-			        key_i(0)
+			        chunk_i(chunk_i)
 			{
 			}
 
@@ -1175,7 +1166,7 @@ class hashtable_chain_spinlock_t
 			hashtable_t* hashtable;
 
 			uint32_t chunk_i;
-			uint32_t key_i;
+			uint32_t key_i{};
 		};
 
 		iterator_t begin() const
@@ -1245,27 +1236,27 @@ class hashtable_chain_spinlock_t
 		}
 
 	public:
-		inline uint32_t getNextExtendedChunkId() const
+		[[nodiscard]] uint32_t getNextExtendedChunkId() const
 		{
 			return nextExtendedChunkId & 0x00FFFFFFu;
 		}
 
-		inline void setNextExtendedChunkId(const uint32_t& extendedChunkId)
+		void setNextExtendedChunkId(const uint32_t& extendedChunkId)
 		{
 			nextExtendedChunkId = (nextExtendedChunkId & 0xFF000000u) | (extendedChunkId & 0x00FFFFFFu);
 		}
 
-		inline bool isValid(const unsigned int& key_i) const
+		[[nodiscard]] bool isValid(const unsigned int& key_i) const
 		{
 			return keyValids & (1u << key_i);
 		}
 
-		inline void setValid(const unsigned int& key_i)
+		void setValid(const unsigned int& key_i)
 		{
 			keyValids |= (1u << key_i);
 		}
 
-		inline void unsetValid(const unsigned int& key_i)
+		void unsetValid(const unsigned int& key_i)
 		{
 			keyValids &= ~(1u << key_i);
 		}
@@ -1277,22 +1268,22 @@ class hashtable_chain_spinlock_t
 			YADECAP_MEMORY_BARRIER_COMPILE;
 		}
 
-		inline const key_T& getKey(unsigned int key_i) const
+		const key_T& getKey(unsigned int key_i) const
 		{
 			return pairs[key_i].key;
 		}
 
-		inline key_T& getKey(unsigned int key_i)
+		key_T& getKey(unsigned int key_i)
 		{
 			return pairs[key_i].key;
 		}
 
-		inline const value_T& getValue(unsigned int key_i) const
+		const value_T& getValue(unsigned int key_i) const
 		{
 			return pairs[key_i].value;
 		}
 
-		inline value_T& getValue(unsigned int key_i)
+		value_T& getValue(unsigned int key_i)
 		{
 			return pairs[key_i].value;
 		}
@@ -1326,27 +1317,27 @@ class hashtable_chain_spinlock_t
 		}
 
 	public:
-		inline uint32_t getNextExtendedChunkId() const
+		[[nodiscard]] uint32_t getNextExtendedChunkId() const
 		{
 			return nextExtendedChunkId & 0x00FFFFFFu;
 		}
 
-		inline void setNextExtendedChunkId(const uint32_t& extendedChunkId)
+		void setNextExtendedChunkId(const uint32_t& extendedChunkId)
 		{
 			nextExtendedChunkId = (nextExtendedChunkId & 0xFF000000u) | (extendedChunkId & 0x00FFFFFFu);
 		}
 
-		inline bool isValid(const unsigned int& key_i) const
+		[[nodiscard]] bool isValid(const unsigned int& key_i) const
 		{
 			return keyValids & (1u << key_i);
 		}
 
-		inline void setValid(const unsigned int& key_i)
+		void setValid(const unsigned int& key_i)
 		{
 			keyValids |= (1u << key_i);
 		}
 
-		inline void unsetValid(const unsigned int& key_i)
+		void unsetValid(const unsigned int& key_i)
 		{
 			keyValids &= ~(1u << key_i);
 		}
@@ -1358,22 +1349,22 @@ class hashtable_chain_spinlock_t
 			YADECAP_MEMORY_BARRIER_COMPILE;
 		}
 
-		inline const key_T& getKey(unsigned int key_i) const
+		const key_T& getKey(unsigned int key_i) const
 		{
 			return pairs[key_i].key;
 		}
 
-		inline key_T& getKey(unsigned int key_i)
+		key_T& getKey(unsigned int key_i)
 		{
 			return pairs[key_i].key;
 		}
 
-		inline const value_T& getValue(unsigned int key_i) const
+		const value_T& getValue(unsigned int key_i) const
 		{
 			return pairs[key_i].value;
 		}
 
-		inline value_T& getValue(unsigned int key_i)
+		value_T& getValue(unsigned int key_i)
 		{
 			return pairs[key_i].value;
 		}
@@ -1398,8 +1389,8 @@ class hashtable_chain_spinlock_t
 	};
 
 protected:
-	static inline bool compareKeys(const key_T& first,
-	                               const key_T& second)
+	static bool compareKeys(const key_T& first,
+	                        const key_T& second)
 	{
 		return !memcmp(&first, &second, sizeof(key_T));
 	}
@@ -1446,14 +1437,14 @@ class hashtable_chain_spinlock_t
 	hashtable_chain_spinlock_stats_t stats_;
 
 public:
-	const hashtable_chain_spinlock_stats_t& stats() const
+	[[nodiscard]] const hashtable_chain_spinlock_stats_t& stats() const
 	{
 		return stats_;
 	}
 
 protected:
 	spinlock_t extendedChunkLocker;
-	uint32_t gcIndex;
+	uint32_t gcIndex{};
 	uint32_t freeExtendedChunkId;
 
 	YADECAP_CACHE_ALIGNED(align1);
@@ -1570,10 +1561,10 @@ class hashtable_mod_id32
 	/// & 1VV	& 0VV		& VVV
 	/// ^ 100	^ 100		^ 100
 	/// = 0VV	= 1VV		= 1VV
-	inline uint32_t lookup(uint32_t (&hashes)[burst_size],
-	                       const key_t (&keys)[burst_size],
-	                       uint32_t (&values)[burst_size],
-	                       const unsigned int count) const
+	uint32_t lookup(uint32_t (&hashes)[burst_size],
+	                const key_t (&keys)[burst_size],
+	                uint32_t (&values)[burst_size],
+	                const unsigned int count) const
 	{
 		uint32_t mask = mask_full;
 
@@ -1654,7 +1645,7 @@ class hashtable_mod_id32
 
 		for (const auto& [key, value] : keys)
 		{
-			eResult insert_result;
+			eResult insert_result = eResult::success;
 			if constexpr (std::is_same_v<update_key_t, key_t>)
 			{
 				insert_result = insert(updater, key, value);
@@ -1754,17 +1745,17 @@ class hashtable_mod_id32
 	} pairs[total_size];
 
 protected:
-	inline bool is_valid(const uint32_t index) const
+	[[nodiscard]] bool is_valid(const uint32_t index) const
 	{
 		return (pairs[index].value >> shift_valid) & 1;
 	}
 
-	inline bool is_equal(const uint32_t index, const key_t& key) const
+	bool is_equal(const uint32_t index, const key_t& key) const
 	{
 		return !memcmp(&pairs[index].key, &key, sizeof(key_t));
 	}
 
-	inline bool is_valid_and_equal(const uint32_t index, const key_t& key) const
+	bool is_valid_and_equal(const uint32_t index, const key_t& key) const
 	{
 		return is_valid(index) && is_equal(index, key);
 	}
@@ -1830,10 +1821,10 @@ class hashtable_mod_id32_dynamic
 	/// valid	invalid
 	/// = 0VV	= 1VV
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
-	inline uint32_t lookup(uint32_t (&hashes)[burst_size],
-	                       const key_t (&keys)[burst_size],
-	                       uint32_t (&values)[burst_size],
-	                       const unsigned int count) const
+	uint32_t lookup(uint32_t (&hashes)[burst_size],
+	                const key_t (&keys)[burst_size],
+	                uint32_t (&values)[burst_size],
+	                const unsigned int count) const
 	{
 		uint32_t mask = mask_full;
 
@@ -1991,17 +1982,17 @@ class hashtable_mod_id32_dynamic
 	}
 
 protected:
-	inline bool is_valid(const uint32_t index) const
+	[[nodiscard]] bool is_valid(const uint32_t index) const
 	{
 		return (pairs[index].value >> shift_valid) & 1;
 	}
 
-	inline bool is_equal(const uint32_t index, const key_t& key) const
+	bool is_equal(const uint32_t index, const key_t& key) const
 	{
 		return !memcmp(&pairs[index].key, &key, sizeof(key_t));
 	}
 
-	inline bool is_valid_and_equal(const uint32_t index, const key_t& key) const
+	bool is_valid_and_equal(const uint32_t index, const key_t& key) const
 	{
 		return is_valid(index) && is_equal(index, key);
 	}
@@ -2079,9 +2070,9 @@ class hashtable_mod_spinlock
 	}
 
 public:
-	inline uint32_t lookup(const key_t& key,
-	                       value_t*& value,
-	                       spinlock_nonrecursive_t*& locker)
+	uint32_t lookup(const key_t& key,
+	                value_t*& value,
+	                spinlock_nonrecursive_t*& locker)
 	{
 		uint32_t hash = calculate_hash(key);
 		auto& chunk = chunks[hash & (total_size / chunk_size - 1)];
@@ -2122,9 +2113,9 @@ class hashtable_mod_spinlock
 		return hash;
 	}
 
-	inline bool insert(const uint32_t hash,
-	                   const key_t& key,
-	                   const value_t& value)
+	bool insert(const uint32_t hash,
+	            const key_t& key,
+	            const value_t& value)
 	{
 		auto& chunk = chunks[hash & (total_size / chunk_size - 1)];
 
@@ -2177,13 +2168,13 @@ class hashtable_mod_spinlock
 		return false;
 	}
 
-	inline bool insert_or_update(const key_t& key,
-	                             const value_t& value)
+	bool insert_or_update(const key_t& key,
+	                      const value_t& value)
 	{
 		bool result = true;
 
-		value_t* ht_value;
-		spinlock_nonrecursive_t* locker;
+		value_t* ht_value = nullptr;
+		spinlock_nonrecursive_t* locker = nullptr;
 
 		uint32_t hash = lookup(key, ht_value, locker);
 		if (ht_value)
@@ -2353,17 +2344,17 @@ class hashtable_mod_spinlock
 		} pairs[chunk_size];
 	} chunks[total_size / chunk_size];
 
-	inline bool is_valid(const chunk_t& chunk, const uint32_t pair_index) const
+	bool is_valid(const chunk_t& chunk, const uint32_t pair_index) const
 	{
 		return (chunk.valid_mask >> pair_index) & 1;
 	}
 
-	inline bool is_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
+	bool is_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
 	{
 		return !memcmp(&chunk.pairs[pair_index].key, &key, sizeof(key_t));
 	}
 
-	inline bool is_valid_and_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
+	bool is_valid_and_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
 	{
 		return is_valid(chunk, pair_index) && is_equal(chunk, pair_index, key);
 	}
@@ -2556,9 +2547,9 @@ class hashtable_mod_spinlock_dynamic
 	}
 
 public:
-	inline uint32_t lookup(const key_t& key,
-	                       value_t*& value,
-	                       spinlock_nonrecursive_t*& locker)
+	uint32_t lookup(const key_t& key,
+	                value_t*& value,
+	                spinlock_nonrecursive_t*& locker)
 	{
 		uint32_t hash = calculate_hash(key);
 		auto& chunk = chunks[hash & total_mask];
@@ -2599,9 +2590,9 @@ class hashtable_mod_spinlock_dynamic
 		return hash;
 	}
 
-	inline bool insert(const uint32_t hash,
-	                   const key_t& key,
-	                   const value_t& value)
+	bool insert(const uint32_t hash,
+	            const key_t& key,
+	            const value_t& value)
 	{
 		auto& chunk = chunks[hash & total_mask];
 
@@ -2654,13 +2645,13 @@ class hashtable_mod_spinlock_dynamic
 		return false;
 	}
 
-	inline bool insert_or_update(const key_t& key,
-	                             const value_t& value)
+	bool insert_or_update(const key_t& key,
+	                      const value_t& value)
 	{
 		bool result = true;
 
-		value_t* ht_value;
-		spinlock_nonrecursive_t* locker;
+		value_t* ht_value = nullptr;
+		spinlock_nonrecursive_t* locker = nullptr;
 
 		uint32_t hash = lookup(key, ht_value, locker);
 		if (ht_value)
@@ -2676,7 +2667,7 @@ class hashtable_mod_spinlock_dynamic
 		return result;
 	}
 
-	inline void remove(const key_t& key)
+	void remove(const key_t& key)
 	{
 		uint32_t hash = calculate_hash(key);
 		auto& chunk = chunks[hash & total_mask];
@@ -2867,17 +2858,17 @@ class hashtable_mod_spinlock_dynamic
 		} pairs[chunk_size];
 	} chunks[];
 
-	inline bool is_valid(const chunk_t& chunk, const uint32_t pair_index) const
+	bool is_valid(const chunk_t& chunk, const uint32_t pair_index) const
 	{
 		return (chunk.valid_mask >> pair_index) & 1;
 	}
 
-	inline bool is_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
+	bool is_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
 	{
 		return !memcmp(&chunk.pairs[pair_index].key, &key, sizeof(key_t));
 	}
 
-	inline bool is_valid_and_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
+	bool is_valid_and_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
 	{
 		return is_valid(chunk, pair_index) && is_equal(chunk, pair_index, key);
 	}
@@ -3106,8 +3097,8 @@ class hashtable_mod_dynamic
 	}
 
 public:
-	inline uint32_t lookup(const key_t& key,
-	                       value_t*& value)
+	uint32_t lookup(const key_t& key,
+	                value_t*& value)
 	{
 		uint32_t hash = calculate_hash(key);
 		auto& chunk = chunks[hash & total_mask];
@@ -3145,8 +3136,8 @@ class hashtable_mod_dynamic
 		return hash;
 	}
 
-	inline uint32_t lookup(const key_t& key,
-	                       value_t const*& value) const
+	uint32_t lookup(const key_t& key,
+	                value_t const*& value) const
 	{
 		uint32_t hash = calculate_hash(key);
 		auto& chunk = chunks[hash & total_mask];
@@ -3184,9 +3175,9 @@ class hashtable_mod_dynamic
 		return hash;
 	}
 
-	inline bool insert(const uint32_t hash,
-	                   const key_t& key,
-	                   const value_t& value)
+	bool insert(const uint32_t hash,
+	            const key_t& key,
+	            const value_t& value)
 	{
 		auto& chunk = chunks[hash & total_mask];
 
@@ -3239,12 +3230,12 @@ class hashtable_mod_dynamic
 		return false;
 	}
 
-	inline bool insert_or_update(const key_t& key,
-	                             const value_t& value)
+	bool insert_or_update(const key_t& key,
+	                      const value_t& value)
 	{
 		bool result = true;
 
-		value_t* ht_value;
+		value_t* ht_value = nullptr;
 
 		uint32_t hash = lookup(key, ht_value);
 		if (ht_value)
@@ -3259,7 +3250,7 @@ class hashtable_mod_dynamic
 		return result;
 	}
 
-	inline bool remove(const key_t& key)
+	bool remove(const key_t& key)
 	{
 		uint32_t hash = calculate_hash(key);
 		auto& chunk = chunks[hash & total_mask];
@@ -3432,17 +3423,17 @@ class hashtable_mod_dynamic
 		} pairs[chunk_size];
 	} chunks[];
 
-	inline bool is_valid(const chunk_t& chunk, const uint32_t pair_index) const
+	bool is_valid(const chunk_t& chunk, const uint32_t pair_index) const
 	{
 		return (chunk.valid_mask >> pair_index) & 1;
 	}
 
-	inline bool is_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
+	bool is_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
 	{
 		return !memcmp(&chunk.pairs[pair_index].key, &key, sizeof(key_t));
 	}
 
-	inline bool is_valid_and_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
+	bool is_valid_and_equal(const chunk_t& chunk, const uint32_t pair_index, const key_t& key) const
 	{
 		return is_valid(chunk, pair_index) && is_equal(chunk, pair_index, key);
 	}
diff --git a/dataplane/icmp.h b/dataplane/icmp.h
index 84a2a692..b6f9faa7 100644
--- a/dataplane/icmp.h
+++ b/dataplane/icmp.h
@@ -10,7 +10,7 @@ inline bool yanet_icmp_translate_v6_to_v4(icmp_header_t* icmpHeader,
                                           uint16_t length,
                                           uint16_t checksum6)
 {
-	uint8_t type;
+	uint8_t type = 0;
 
 	if (icmpHeader->type == ICMP6_ECHO_REQUEST)
 	{
@@ -46,7 +46,7 @@ inline bool yanet_icmp_translate_v4_to_v6(icmp_header_t* icmpHeader,
                                           uint16_t length,
                                           uint16_t checksum6)
 {
-	uint8_t type;
+	uint8_t type = 0;
 
 	if (icmpHeader->type == ICMP_ECHO)
 	{
diff --git a/dataplane/icmp_translations.cpp b/dataplane/icmp_translations.cpp
index 25fe1ec1..7151a525 100644
--- a/dataplane/icmp_translations.cpp
+++ b/dataplane/icmp_translations.cpp
@@ -1,4 +1,7 @@
 #include "icmp_translations.h"
+#include "checksum.h"
+#include "dataplane/icmp.h"
+#include "metadata.h"
 
 namespace dataplane
 {
@@ -155,7 +158,7 @@ bool do_icmp_translate_v6_to_v4(rte_mbuf* mbuf,
 		{
 			return false;
 		}
-		tIPv6ExtensionFragment* extension = (tIPv6ExtensionFragment*)(((char*)ipv6PayloadHeader) + ipv6PayloadHeaderSize);
+		auto* extension = (tIPv6ExtensionFragment*)(((char*)ipv6PayloadHeader) + ipv6PayloadHeaderSize);
 		packet_id = static_cast<uint16_t>(extension->identification >> 16);
 		fragment_offset = rte_cpu_to_be_16(rte_be_to_cpu_16(extension->offsetFlagM) >> 3);
 		fragment_offset |= (extension->offsetFlagM & 0x0100) >> 3;
@@ -182,7 +185,7 @@ bool do_icmp_translate_v6_to_v4(rte_mbuf* mbuf,
 		nextPayloadHeader = IPPROTO_ICMP;
 	}
 
-	rte_ipv4_hdr* ipv4PayloadHeader = (rte_ipv4_hdr*)((char*)ipv6PayloadHeader + ipv6PayloadHeaderSize - sizeof(rte_ipv4_hdr));
+	auto* ipv4PayloadHeader = (rte_ipv4_hdr*)((char*)ipv6PayloadHeader + ipv6PayloadHeaderSize - sizeof(rte_ipv4_hdr));
 
 	ipv4PayloadHeader->version_ihl = 0x45;
 	ipv4PayloadHeader->type_of_service = (rte_be_to_cpu_32(ipv6PayloadHeader->vtc_flow) >> 20) & 0xFF;
@@ -223,21 +226,21 @@ bool do_icmp_translate_v6_to_v4(rte_mbuf* mbuf,
 		{
 			/// @todo: check packet size
 
-			rte_tcp_hdr* tcpPayloadHeader = (rte_tcp_hdr*)((char*)ipv4PayloadHeader + sizeof(rte_ipv4_hdr));
+			auto* tcpPayloadHeader = (rte_tcp_hdr*)((char*)ipv4PayloadHeader + sizeof(rte_ipv4_hdr));
 			yanet_tcp_checksum_v6_to_v4(tcpPayloadHeader, checksum6, checksum4);
 		}
 		else if (nextPayloadHeader == IPPROTO_UDP)
 		{
 			/// @todo: check packet size
 
-			rte_udp_hdr* udpPayloadHeader = (rte_udp_hdr*)((char*)ipv4PayloadHeader + sizeof(rte_ipv4_hdr));
+			auto* udpPayloadHeader = (rte_udp_hdr*)((char*)ipv4PayloadHeader + sizeof(rte_ipv4_hdr));
 			yanet_udp_checksum_v6_to_v4(udpPayloadHeader, checksum6, checksum4);
 		}
 		else if (nextPayloadHeader == IPPROTO_ICMP)
 		{
 			/// @todo: check packet size
 
-			icmp_header_t* icmpPayloadHeader = (icmp_header_t*)((char*)ipv4PayloadHeader + sizeof(rte_ipv4_hdr));
+			auto* icmpPayloadHeader = (icmp_header_t*)((char*)ipv4PayloadHeader + sizeof(rte_ipv4_hdr));
 
 			if ((fragment_offset & 0xFF3F) != 0 ||
 			    !yanet_icmp_translate_v6_to_v4(icmpPayloadHeader,
@@ -431,7 +434,7 @@ bool do_icmp_translate_v4_to_v6(rte_mbuf* mbuf,
 
 	if ((fragment_offset & 0xFF3F) != 0)
 	{
-		tIPv6ExtensionFragment* extension = (tIPv6ExtensionFragment*)(((char*)ipv6PayloadHeader) + sizeof(rte_ipv6_hdr));
+		auto* extension = (tIPv6ExtensionFragment*)(((char*)ipv6PayloadHeader) + sizeof(rte_ipv6_hdr));
 		extension->nextHeader = nextPayloadHeader;
 		extension->reserved = 0;
 		extension->offsetFlagM = rte_cpu_to_be_16(rte_be_to_cpu_16(fragment_offset) << 3);
@@ -470,21 +473,21 @@ bool do_icmp_translate_v4_to_v6(rte_mbuf* mbuf,
 		{
 			/// @todo: check packet size
 
-			rte_tcp_hdr* tcpPayloadHeader = (rte_tcp_hdr*)((char*)ipv6PayloadHeader + ipv6PayloadHeaderSize);
+			auto* tcpPayloadHeader = (rte_tcp_hdr*)((char*)ipv6PayloadHeader + ipv6PayloadHeaderSize);
 			yanet_tcp_checksum_v4_to_v6(tcpPayloadHeader, checksum4, checksum6);
 		}
 		else if (nextPayloadHeader == IPPROTO_UDP)
 		{
 			/// @todo: check packet size
 
-			rte_udp_hdr* udpPayloadHeader = (rte_udp_hdr*)((char*)ipv6PayloadHeader + ipv6PayloadHeaderSize);
+			auto* udpPayloadHeader = (rte_udp_hdr*)((char*)ipv6PayloadHeader + ipv6PayloadHeaderSize);
 			yanet_udp_checksum_v4_to_v6(udpPayloadHeader, checksum4, checksum6);
 		}
 		else if (nextPayloadHeader == IPPROTO_ICMPV6)
 		{
 			/// @todo: check packet size
 
-			icmp_header_t* icmpPayloadHeader = (icmp_header_t*)((char*)ipv6PayloadHeader + ipv6PayloadHeaderSize);
+			auto* icmpPayloadHeader = (icmp_header_t*)((char*)ipv6PayloadHeader + ipv6PayloadHeaderSize);
 
 			if ((fragment_offset & 0xFF3F) != 0 ||
 			    !yanet_icmp_translate_v4_to_v6(icmpPayloadHeader,
@@ -513,4 +516,4 @@ bool do_icmp_translate_v4_to_v6(rte_mbuf* mbuf,
 	return true;
 }
 
-} // namespace dataplane
\ No newline at end of file
+} // namespace dataplane
diff --git a/dataplane/icmp_translations.h b/dataplane/icmp_translations.h
index 333701c5..f696d284 100644
--- a/dataplane/icmp_translations.h
+++ b/dataplane/icmp_translations.h
@@ -1,7 +1,6 @@
 #include <rte_mbuf.h>
 
-#include "globalbase.h"
-#include "icmp.h"
+#include "type.h"
 
 namespace dataplane
 {
@@ -10,4 +9,4 @@ bool do_icmp_translate_v6_to_v4(rte_mbuf* mbuf,
 bool do_icmp_translate_v4_to_v6(rte_mbuf* mbuf,
                                 const dataplane::globalBase::nat64stateless_translation_t& translation);
 
-} // namespace dataplane
\ No newline at end of file
+} // namespace dataplane
diff --git a/dataplane/kernel_interface_handle.cpp b/dataplane/kernel_interface_handle.cpp
index db4a1555..34a10d89 100644
--- a/dataplane/kernel_interface_handle.cpp
+++ b/dataplane/kernel_interface_handle.cpp
@@ -42,7 +42,7 @@ KernelInterfaceHandle::KernelInterfaceHandle(KernelInterfaceHandle&& other) noex
 	*this = std::move(other);
 }
 
-bool KernelInterfaceHandle::Start() const
+bool KernelInterfaceHandle::Start() const noexcept
 {
 	auto rc = rte_eth_dev_start(kni_port_);
 	if (rc)
@@ -138,7 +138,7 @@ rte_eth_conf KernelInterfaceHandle::DefaultConfig() noexcept
 	return rte_eth_conf{};
 }
 
-bool KernelInterfaceHandle::Configure(const rte_eth_conf& eth_conf, tQueueId queue_count)
+bool KernelInterfaceHandle::Configure(const rte_eth_conf& eth_conf, tQueueId queue_count) noexcept
 {
 	int ret = rte_eth_dev_configure(kni_port_,
 	                                queue_count,
@@ -154,7 +154,7 @@ bool KernelInterfaceHandle::Configure(const rte_eth_conf& eth_conf, tQueueId que
 
 bool KernelInterfaceHandle::CloneMTU(const uint16_t port_id) noexcept
 {
-	uint16_t mtu;
+	uint16_t mtu = 0;
 	if (rte_eth_dev_get_mtu(port_id, &mtu))
 	{
 		return (rte_eth_dev_set_mtu(kni_port_, mtu) == 0);
@@ -195,4 +195,4 @@ bool KernelInterfaceHandle::SetupTxQueue(tQueueId queue, tSocketId socket) noexc
 	return true;
 }
 
-} // namespace dataplane
\ No newline at end of file
+} // namespace dataplane
diff --git a/dataplane/kernel_interface_handle.h b/dataplane/kernel_interface_handle.h
index 94569104..bad5ef26 100644
--- a/dataplane/kernel_interface_handle.h
+++ b/dataplane/kernel_interface_handle.h
@@ -27,8 +27,8 @@ class KernelInterfaceHandle
 	                          tPortId port,
 	                          tQueueId queue_count,
 	                          uint16_t queue_size) noexcept;
-	const tPortId& Id() const noexcept { return kni_port_; }
-	bool Start() const noexcept;
+	[[nodiscard]] const tPortId& Id() const noexcept { return kni_port_; }
+	[[nodiscard]] bool Start() const noexcept;
 	[[nodiscard]] bool SetUp() const noexcept;
 	bool SetupRxQueue(tQueueId queue, tSocketId socket, rte_mempool* mempool) noexcept;
 	bool SetupTxQueue(tQueueId queue, tSocketId socket) noexcept;
@@ -45,4 +45,4 @@ class KernelInterfaceHandle
 	[[nodiscard]] bool Valid() const { return kni_port_ != INVALID_PORT_ID; }
 };
 
-} // namespace dataplane
\ No newline at end of file
+} // namespace dataplane
diff --git a/dataplane/kernel_interface_handler.cpp b/dataplane/kernel_interface_handler.cpp
index a8a06e4d..980f39a5 100644
--- a/dataplane/kernel_interface_handler.cpp
+++ b/dataplane/kernel_interface_handler.cpp
@@ -1,4 +1,5 @@
 #include "kernel_interface_handler.h"
+#include "metadata.h"
 
 namespace dataplane
 {
@@ -251,4 +252,4 @@ void KernelInterfaceWorker::HandlePacketFromForwardingPlane(rte_mbuf* mbuf)
 	stats_[i].odropped += delta.dropped;
 }
 
-} // namespace dataplane
\ No newline at end of file
+} // namespace dataplane
diff --git a/dataplane/kernel_interface_handler.h b/dataplane/kernel_interface_handler.h
index c3b43728..c473983d 100644
--- a/dataplane/kernel_interface_handler.h
+++ b/dataplane/kernel_interface_handler.h
@@ -5,7 +5,6 @@
 
 #include "base.h"
 #include "dpdk.h"
-#include "metadata.h"
 
 namespace dataplane
 {
@@ -40,8 +39,8 @@ class KernelInterface
 	DirectionStats FlushTracked();
 	void Push(rte_mbuf* mbuf);
 	DirectionStats PushTracked(rte_mbuf* mbuf);
-	const tPortId& port() const;
-	const tQueueId& queue() const;
+	[[nodiscard]] const tPortId& port() const;
+	[[nodiscard]] const tQueueId& queue() const;
 };
 
 struct KernelInterfaceBundleConfig
@@ -84,9 +83,9 @@ class KernelInterfaceWorker
 	KernelInterfaceWorker(std::vector<KernelInterfaceBundleConfig>& config);
 	KernelInterfaceWorker(KernelInterfaceWorker&& other);
 	KernelInterfaceWorker& operator=(KernelInterfaceWorker&& other);
-	ConstPortArrayRange<tPortId> PortsIds() const;
-	ConstPortArrayRange<sKniStats> PortsStats() const;
-	std::optional<std::reference_wrapper<const sKniStats>> PortStats(tPortId pid) const;
+	[[nodiscard]] ConstPortArrayRange<tPortId> PortsIds() const;
+	[[nodiscard]] ConstPortArrayRange<sKniStats> PortsStats() const;
+	[[nodiscard]] std::optional<std::reference_wrapper<const sKniStats>> PortStats(tPortId pid) const;
 
 	/// @brief Transmit accumulated packets. Those that could not be sent are freed
 	void Flush();
@@ -97,4 +96,4 @@ class KernelInterfaceWorker
 	void HandlePacketDump(rte_mbuf* mbuf);
 	void HandlePacketFromForwardingPlane(rte_mbuf* mbuf);
 };
-} // namespace dataplane
\ No newline at end of file
+} // namespace dataplane
diff --git a/dataplane/lpm.h b/dataplane/lpm.h
index 672f861c..51f5090d 100644
--- a/dataplane/lpm.h
+++ b/dataplane/lpm.h
@@ -1,9 +1,6 @@
 #pragma once
 
 #include <memory.h>
-#include <unordered_map>
-#include <unordered_set>
-
 #include <rte_byteorder.h>
 #include <rte_common.h>
 #include <rte_ip.h>
@@ -68,9 +65,7 @@ class lpm4_24bit_8bit_atomic
 	}
 
 public:
-	lpm4_24bit_8bit_atomic()
-	{
-	}
+	lpm4_24bit_8bit_atomic() = default;
 
 	eResult insert(stats_t& stats,
 	               const uint32_t& ipAddress,
@@ -138,9 +133,9 @@ class lpm4_24bit_8bit_atomic
 		return copy_root_chunk(stats, remap_chunks, second);
 	}
 
-	inline void lookup(const uint32_t* ipAddresses,
-	                   uint32_t* valueIds,
-	                   const unsigned int& count) const
+	void lookup(const uint32_t* ipAddresses,
+	            uint32_t* valueIds,
+	            const unsigned int& count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -175,9 +170,9 @@ class lpm4_24bit_8bit_atomic
 	}
 
 	template<unsigned int TOffset>
-	inline void lookup(rte_mbuf** mbufs,
-	                   uint32_t* valueIds,
-	                   const unsigned int& count) const
+	void lookup(rte_mbuf** mbufs,
+	            uint32_t* valueIds,
+	            const unsigned int& count) const
 	{
 		uint32_t ipAddresses[CONFIG_YADECAP_MBUFS_BURST_SIZE];
 
@@ -194,10 +189,10 @@ class lpm4_24bit_8bit_atomic
 		lookup(ipAddresses, valueIds, count);
 	}
 
-	inline bool lookup(const uint32_t& ipAddress,
-	                   uint32_t* valueId = nullptr) const
+	bool lookup(const uint32_t& ipAddress,
+	            uint32_t* valueId = nullptr) const
 	{
-		uint32_t lvalueId;
+		uint32_t lvalueId = 0;
 
 		lookup(&ipAddress, &lvalueId, 1);
 
@@ -306,11 +301,9 @@ class lpm4_24bit_8bit_atomic
 
 		YADECAP_MEMORY_BARRIER_COMPILE;
 
-		for (unsigned int entry_i = 0;
-		     entry_i < 256;
-		     entry_i++)
+		for (auto& entrie : chunk.entries)
 		{
-			chunk.entries[entry_i].atomic = newEntry.atomic;
+			entrie.atomic = newEntry.atomic;
 		}
 
 		chunk.entries[0].flags |= flag;
@@ -348,12 +341,10 @@ class lpm4_24bit_8bit_atomic
 				}
 
 				bool merge = true;
-				for (unsigned int next_entry_i = 0;
-				     next_entry_i < 256;
-				     next_entry_i++)
+				for (auto& entrie : extendedChunks[extendedChunkId].entries)
 				{
-					if (!(extendedChunks[extendedChunkId].entries[next_entry_i].flags & flagValid &&
-					      extendedChunks[extendedChunkId].entries[next_entry_i].valueId == valueId))
+					if (!(entrie.flags & flagValid &&
+					      entrie.valueId == valueId))
 					{
 						merge = false;
 						break;
@@ -385,7 +376,7 @@ class lpm4_24bit_8bit_atomic
 					return eResult::success;
 				}
 
-				uint32_t extendedChunkId;
+				uint32_t extendedChunkId = 0;
 				if (!newExtendedChunk(stats, extendedChunkId))
 				{
 					return eResult::isFull;
@@ -459,8 +450,8 @@ class lpm4_24bit_8bit_atomic
 	                    const unsigned int& step,
 	                    tChunk8& chunk)
 	{
-		(void)needWait;
-		(void)step;
+		YANET_GCC_BUG_UNUSED(needWait);
+		YANET_GCC_BUG_UNUSED(step);
 
 		for (unsigned int mask_i = 0;
 		     mask_i < (((unsigned int)1) << (8 - mask));
@@ -504,11 +495,9 @@ class lpm4_24bit_8bit_atomic
 				}
 
 				bool isEmpty = true;
-				for (unsigned int next_entry_i = 0;
-				     next_entry_i < 256;
-				     next_entry_i++)
+				for (auto& entrie : extendedChunks[extendedChunkId].entries)
 				{
-					if (extendedChunks[extendedChunkId].entries[next_entry_i].flags & (flagExtended | flagValid))
+					if (entrie.flags & (flagExtended | flagValid))
 					{
 						isEmpty = false;
 						break;
@@ -534,7 +523,7 @@ class lpm4_24bit_8bit_atomic
 			{
 				/// valid
 
-				uint32_t extendedChunkId;
+				uint32_t extendedChunkId = 0;
 				if (!newExtendedChunk(stats, extendedChunkId))
 				{
 					return eResult::isFull;
@@ -613,8 +602,8 @@ class lpm4_24bit_8bit_atomic
 	                    const unsigned int& step,
 	                    tChunk8& chunk)
 	{
-		(void)needWait;
-		(void)step;
+		YANET_GCC_BUG_UNUSED(needWait);
+		YANET_GCC_BUG_UNUSED(step);
 
 		for (unsigned int mask_i = 0;
 		     mask_i < (((unsigned int)1) << (8 - mask));
@@ -639,12 +628,8 @@ class lpm4_24bit_8bit_atomic
 		memcpy(rootChunk.entries, from_chunk.entries, sizeof(from_chunk.entries));
 		std::vector<std::tuple<unsigned int, unsigned int>> nexts;
 
-		for (uint32_t i = 0;
-		     i < (1u << 24);
-		     i++)
+		for (auto& chunk_value : rootChunk.entries)
 		{
-			auto& chunk_value = rootChunk.entries[i];
-
 			if (chunk_value.flags & flagExtended)
 			{
 				auto& chunk_id = remap_chunks[chunk_value.extendedChunkId];
@@ -741,9 +726,7 @@ class lpm6_8x16bit_atomic
 	}
 
 public:
-	lpm6_8x16bit_atomic()
-	{
-	}
+	lpm6_8x16bit_atomic() = default;
 
 	static std::array<uint8_t, 16> createMask(uint8_t ones)
 	{
@@ -831,9 +814,9 @@ class lpm6_8x16bit_atomic
 		return copy_root_chunk(stats, remap_chunks, second);
 	}
 
-	inline void lookup(const ipv6_address_t* ipv6Addresses,
-	                   uint32_t* valueIds,
-	                   const unsigned int& count) const
+	void lookup(const ipv6_address_t* ipv6Addresses,
+	            uint32_t* valueIds,
+	            const unsigned int& count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -876,10 +859,10 @@ class lpm6_8x16bit_atomic
 
 	constexpr static uint32_t mask_full = 0xFFFFFFFFu;
 
-	inline void lookup(const uint32_t mask,
-	                   const ipv6_address_t* ipv6Addresses,
-	                   uint32_t* valueIds,
-	                   const unsigned int& count) const
+	void lookup(const uint32_t mask,
+	            const ipv6_address_t* ipv6Addresses,
+	            uint32_t* valueIds,
+	            const unsigned int& count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -931,9 +914,9 @@ class lpm6_8x16bit_atomic
 	}
 
 	template<unsigned int TOffset>
-	inline void lookup(rte_mbuf** mbufs,
-	                   uint32_t* valueIds,
-	                   const unsigned int& count) const
+	void lookup(rte_mbuf** mbufs,
+	            uint32_t* valueIds,
+	            const unsigned int& count) const
 	{
 		ipv6_address_t ipv6Addresses[CONFIG_YADECAP_MBUFS_BURST_SIZE];
 
@@ -952,11 +935,11 @@ class lpm6_8x16bit_atomic
 		lookup(ipv6Addresses, valueIds, count);
 	}
 
-	inline bool lookup(const std::array<uint8_t, 16>& ipv6Address,
-	                   uint32_t* valueId = nullptr) const
+	bool lookup(const std::array<uint8_t, 16>& ipv6Address,
+	            uint32_t* valueId = nullptr) const
 	{
 		ipv6_address_t lipv6Address;
-		uint32_t lvalueId;
+		uint32_t lvalueId = 0;
 
 		memcpy(lipv6Address.bytes, ipv6Address.data(), 16);
 		lookup(&lipv6Address, &lvalueId, 1);
@@ -974,11 +957,11 @@ class lpm6_8x16bit_atomic
 		return false;
 	}
 
-	inline bool lookup(const uint8_t* ipv6_address,
-	                   uint32_t* value_id = nullptr) const
+	bool lookup(const uint8_t* ipv6_address,
+	            uint32_t* value_id = nullptr) const
 	{
 		ipv6_address_t lipv6Address;
-		uint32_t lvalueId;
+		uint32_t lvalueId = 0;
 
 		memcpy(lipv6Address.bytes, ipv6_address, 16);
 		lookup(&lipv6Address, &lvalueId, 1);
@@ -1047,13 +1030,11 @@ class lpm6_8x16bit_atomic
 			return;
 		}
 
-		for (unsigned int entry_i = 0;
-		     entry_i < 256 * 256;
-		     entry_i++)
+		for (auto& entrie : extendedChunk.entries)
 		{
-			if (extendedChunk.entries[entry_i].flags & flagExtended)
+			if (entrie.flags & flagExtended)
 			{
-				freeExtendedChunk(stats, extendedChunk.entries[entry_i].extendedChunkId);
+				freeExtendedChunk(stats, entrie.extendedChunkId);
 			}
 		}
 
@@ -1092,11 +1073,9 @@ class lpm6_8x16bit_atomic
 
 		YADECAP_MEMORY_BARRIER_COMPILE;
 
-		for (unsigned int entry_i = 0;
-		     entry_i < 256 * 256;
-		     entry_i++)
+		for (auto& entrie : chunk.entries)
 		{
-			chunk.entries[entry_i].atomic = newEntry.atomic;
+			entrie.atomic = newEntry.atomic;
 		}
 
 		chunk.entries[0].flags |= flag;
@@ -1157,12 +1136,10 @@ class lpm6_8x16bit_atomic
 				}
 
 				bool merge = true;
-				for (unsigned int next_entry_i = 0;
-				     next_entry_i < 256 * 256;
-				     next_entry_i++)
+				for (auto& entrie : extendedChunks[extendedChunkId].entries)
 				{
-					if (!(extendedChunks[extendedChunkId].entries[next_entry_i].flags & flagValid &&
-					      extendedChunks[extendedChunkId].entries[next_entry_i].valueId == valueId))
+					if (!(entrie.flags & flagValid &&
+					      entrie.valueId == valueId))
 					{
 						merge = false;
 						break;
@@ -1194,7 +1171,7 @@ class lpm6_8x16bit_atomic
 					return eResult::success;
 				}
 
-				uint32_t extendedChunkId;
+				uint32_t extendedChunkId = 0;
 				if (!newExtendedChunk(stats, extendedChunkId))
 				{
 					YADECAP_LOG_WARNING("lpm6 is full\n");
@@ -1292,11 +1269,9 @@ class lpm6_8x16bit_atomic
 				}
 
 				bool isEmpty = true;
-				for (unsigned int next_entry_i = 0;
-				     next_entry_i < 256 * 256;
-				     next_entry_i++)
+				for (auto& entrie : extendedChunks[extendedChunkId].entries)
 				{
-					if (extendedChunks[extendedChunkId].entries[next_entry_i].flags & (flagExtended | flagValid))
+					if (entrie.flags & (flagExtended | flagValid))
 					{
 						isEmpty = false;
 						break;
@@ -1322,7 +1297,7 @@ class lpm6_8x16bit_atomic
 			{
 				/// valid
 
-				uint32_t extendedChunkId;
+				uint32_t extendedChunkId = 0;
 				if (!newExtendedChunk(stats, extendedChunkId))
 				{
 					YADECAP_LOG_WARNING("lpm6 is full\n");
@@ -1406,12 +1381,8 @@ class lpm6_8x16bit_atomic
 		memcpy(rootChunk.entries, from_chunk.entries, sizeof(from_chunk.entries));
 		std::vector<std::tuple<unsigned int, unsigned int>> nexts;
 
-		for (uint32_t i = 0;
-		     i < (1u << 16);
-		     i++)
+		for (auto& chunk_value : rootChunk.entries)
 		{
-			auto& chunk_value = rootChunk.entries[i];
-
 			if (chunk_value.flags & flagExtended)
 			{
 				auto& chunk_id = remap_chunks[chunk_value.extendedChunkId];
@@ -1453,12 +1424,8 @@ class lpm6_8x16bit_atomic
 		memcpy(chunk.entries, from_chunk.entries, sizeof(from_chunk.entries));
 		std::vector<std::tuple<unsigned int, unsigned int>> nexts;
 
-		for (uint32_t i = 0;
-		     i < (1u << 16);
-		     i++)
+		for (auto& chunk_value : chunk.entries)
 		{
-			auto& chunk_value = chunk.entries[i];
-
 			if (chunk_value.flags & flagExtended)
 			{
 				auto& chunk_id = remap_chunks[chunk_value.extendedChunkId];
@@ -1502,10 +1469,7 @@ class lpm4_24bit_8bit_id32
 	class updater
 	{
 	public:
-		updater() :
-		        extended_chunks_count(1)
-		{
-		}
+		updater() = default;
 
 		void clear(const unsigned int tree_size)
 		{
@@ -1514,7 +1478,7 @@ class lpm4_24bit_8bit_id32
 			remap_chunks.resize(tree_size, 0);
 		}
 
-		inline unsigned int allocate_extended_chunk()
+		unsigned int allocate_extended_chunk()
 		{
 			if (extended_chunks_count >= extended_chunks_size)
 			{
@@ -1527,23 +1491,23 @@ class lpm4_24bit_8bit_id32
 			return new_chunk_id;
 		}
 
-		inline unsigned int& remap(const unsigned int from_chunk_id)
+		unsigned int& remap(const unsigned int from_chunk_id)
 		{
 			return remap_chunks[from_chunk_id];
 		}
 
-		unsigned int get_extended_chunks_count() const
+		[[nodiscard]] unsigned int get_extended_chunks_count() const
 		{
 			return extended_chunks_count;
 		}
 
-		unsigned int get_extended_chunks_size() const
+		[[nodiscard]] unsigned int get_extended_chunks_size() const
 		{
 			return extended_chunks_size;
 		}
 
 	public:
-		unsigned int extended_chunks_count;
+		unsigned int extended_chunks_count{1};
 		std::vector<unsigned int> remap_chunks;
 	};
 
@@ -1576,9 +1540,9 @@ class lpm4_24bit_8bit_id32
 
 public:
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
-	inline void lookup(const ipv4_address_t (&addresses)[burst_size],
-	                   uint32_t (&group_ids)[burst_size],
-	                   const unsigned int count) const
+	void lookup(const ipv4_address_t (&addresses)[burst_size],
+	            uint32_t (&group_ids)[burst_size],
+	            const unsigned int count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -1616,12 +1580,9 @@ class lpm4_24bit_8bit_id32
 
 	struct value_t
 	{
-		value_t() :
-		        id(0)
-		{
-		}
+		value_t() = default;
 
-		uint32_t id;
+		uint32_t id{};
 	};
 
 	struct chunk_step1_t
@@ -1726,7 +1687,7 @@ class lpm4_24bit_8bit_id32
 	                              const unsigned int from_chunk_id,
 	                              const unsigned int extended_chunk_id)
 	{
-		(void)updater;
+		YANET_GCC_BUG_UNUSED(updater);
 
 		const auto& from_chunk = from_chunks[from_chunk_id];
 		auto& extended_chunk = extended_chunks[extended_chunk_id];
@@ -1788,9 +1749,9 @@ class lpm4_24bit_8bit_id32_dynamic
 	}
 
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
-	inline void lookup(const ipv4_address_t (&addresses)[burst_size],
-	                   uint32_t (&group_ids)[burst_size],
-	                   const unsigned int count) const
+	void lookup(const ipv4_address_t (&addresses)[burst_size],
+	            uint32_t (&group_ids)[burst_size],
+	            const unsigned int count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -1985,10 +1946,7 @@ class lpm6_8x16bit_id32
 	class updater
 	{
 	public:
-		updater() :
-		        chunks_count(1) ///< 0 is root chunk
-		{
-		}
+		updater() = default;
 
 		void clear(const unsigned int tree_size)
 		{
@@ -1997,7 +1955,7 @@ class lpm6_8x16bit_id32
 			remap_chunks.resize(tree_size, 0);
 		}
 
-		inline unsigned int allocate_chunk()
+		unsigned int allocate_chunk()
 		{
 			if (chunks_count >= chunks_size)
 			{
@@ -2010,13 +1968,13 @@ class lpm6_8x16bit_id32
 			return new_chunk_id;
 		}
 
-		inline unsigned int& remap(const unsigned int from_chunk_id)
+		unsigned int& remap(const unsigned int from_chunk_id)
 		{
 			return remap_chunks[from_chunk_id];
 		}
 
 	public:
-		unsigned int chunks_count;
+		unsigned int chunks_count{1}; ///< 0 is root chunk
 		std::vector<unsigned int> remap_chunks;
 	};
 
@@ -2049,9 +2007,9 @@ class lpm6_8x16bit_id32
 
 public:
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
-	inline void lookup(const ipv6_address_t (&addresses)[burst_size],
-	                   uint32_t (&group_ids)[burst_size],
-	                   const unsigned int count) const
+	void lookup(const ipv6_address_t (&addresses)[burst_size],
+	            uint32_t (&group_ids)[burst_size],
+	            const unsigned int count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -2084,10 +2042,10 @@ class lpm6_8x16bit_id32
 	}
 
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
-	inline void lookup(const uint32_t mask,
-	                   const ipv6_address_t (&addresses)[burst_size],
-	                   uint32_t (&group_ids)[burst_size],
-	                   const unsigned int count) const
+	void lookup(const uint32_t mask,
+	            const ipv6_address_t (&addresses)[burst_size],
+	            uint32_t (&group_ids)[burst_size],
+	            const unsigned int count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -2143,12 +2101,9 @@ class lpm6_8x16bit_id32
 
 	struct value_t
 	{
-		value_t() :
-		        id(0)
-		{
-		}
+		value_t() = default;
 
-		uint32_t id;
+		uint32_t id{};
 	};
 
 	struct chunk_t
@@ -2238,11 +2193,7 @@ class lpm6_8x16bit_id32_dynamic
 	class updater
 	{
 	public:
-		updater() :
-		        lpm(nullptr),
-		        chunks_size(0)
-		{
-		}
+		updater() = default;
 
 		void update_pointer(lpm6_8x16bit_id32_dynamic* lpm,
 		                    const tSocketId socket_id,
@@ -2279,7 +2230,7 @@ class lpm6_8x16bit_id32_dynamic
 		}
 
 	protected:
-		inline unsigned int allocate_chunk()
+		unsigned int allocate_chunk()
 		{
 			if (chunks_count >= chunks_size)
 			{
@@ -2325,12 +2276,8 @@ class lpm6_8x16bit_id32_dynamic
 
 			std::vector<std::tuple<unsigned int, unsigned int>> nexts;
 
-			for (uint32_t i = 0;
-			     i < (1u << bits);
-			     i++)
+			for (auto& chunk_value : chunk.values)
 			{
-				auto& chunk_value = chunk.values[i];
-
 				if (chunk_value.id & 0x80000000u) ///< is_chunk_id
 				{
 					auto& chunk_id = remap_chunks[chunk_value.id ^ 0x80000000u];
@@ -2362,9 +2309,9 @@ class lpm6_8x16bit_id32_dynamic
 		}
 
 	public:
-		lpm6_8x16bit_id32_dynamic* lpm;
+		lpm6_8x16bit_id32_dynamic* lpm{};
 		tSocketId socket_id;
-		unsigned int chunks_size;
+		unsigned int chunks_size{};
 		unsigned int chunks_count;
 		std::vector<unsigned int> remap_chunks;
 	};
@@ -2383,9 +2330,9 @@ class lpm6_8x16bit_id32_dynamic
 
 public:
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
-	inline void lookup(const ipv6_address_t (&addresses)[burst_size],
-	                   uint32_t (&group_ids)[burst_size],
-	                   const unsigned int count) const
+	void lookup(const ipv6_address_t (&addresses)[burst_size],
+	            uint32_t (&group_ids)[burst_size],
+	            const unsigned int count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -2418,10 +2365,10 @@ class lpm6_8x16bit_id32_dynamic
 	}
 
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
-	inline void lookup(const uint32_t mask,
-	                   const ipv6_address_t (&addresses)[burst_size],
-	                   uint32_t (&group_ids)[burst_size],
-	                   const unsigned int count) const
+	void lookup(const uint32_t mask,
+	            const ipv6_address_t (&addresses)[burst_size],
+	            uint32_t (&group_ids)[burst_size],
+	            const unsigned int count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -2470,12 +2417,9 @@ class lpm6_8x16bit_id32_dynamic
 
 	struct value_t
 	{
-		value_t() :
-		        id(0)
-		{
-		}
+		value_t() = default;
 
-		uint32_t id;
+		uint32_t id{};
 	};
 
 	struct chunk_t
@@ -2519,9 +2463,9 @@ class lpm6_16x8bit_id32_dynamic
 	}
 
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
-	inline void lookup(const ipv6_address_t (&addresses)[burst_size],
-	                   uint32_t (&group_ids)[burst_size],
-	                   const unsigned int count) const
+	void lookup(const ipv6_address_t (&addresses)[burst_size],
+	            uint32_t (&group_ids)[burst_size],
+	            const unsigned int count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -2554,10 +2498,10 @@ class lpm6_16x8bit_id32_dynamic
 	}
 
 	template<unsigned int burst_size = YANET_CONFIG_BURST_SIZE>
-	inline void lookup(const uint32_t mask,
-	                   const ipv6_address_t (&addresses)[burst_size],
-	                   uint32_t (&group_ids)[burst_size],
-	                   const unsigned int count) const
+	void lookup(const uint32_t mask,
+	            const ipv6_address_t (&addresses)[burst_size],
+	            uint32_t (&group_ids)[burst_size],
+	            const unsigned int count) const
 	{
 		/// @todo: OPT: le -> be
 
@@ -2618,7 +2562,7 @@ class lpm6_16x8bit_id32_dynamic
 	constexpr static unsigned int root_chunk_id = 0;
 	constexpr static uint32_t mask_full = 0xFFFFFFFFu;
 
-	inline unsigned int allocate_extended_chunk(stats_t& stats)
+	unsigned int allocate_extended_chunk(stats_t& stats)
 	{
 		if (stats.extended_chunks_count >= stats.extended_chunks_size)
 		{
@@ -2645,12 +2589,8 @@ class lpm6_16x8bit_id32_dynamic
 
 		std::vector<std::tuple<unsigned int, unsigned int>> nexts;
 
-		for (uint32_t i = 0;
-		     i < (1u << bits);
-		     i++)
+		for (auto& chunk_value : chunk.values)
 		{
-			auto& chunk_value = chunk.values[i];
-
 			if (chunk_value.id & 0x80000000u) ///< is_chunk_id
 			{
 				auto& chunk_id = stats.remap_chunks[chunk_value.id ^ 0x80000000u];
@@ -2684,12 +2624,9 @@ class lpm6_16x8bit_id32_dynamic
 protected:
 	struct value_t
 	{
-		value_t() :
-		        id(0)
-		{
-		}
+		value_t() = default;
 
-		uint32_t id;
+		uint32_t id{};
 	};
 
 	struct chunk_t
diff --git a/dataplane/main.cpp b/dataplane/main.cpp
index af754505..ec0bba7f 100644
--- a/dataplane/main.cpp
+++ b/dataplane/main.cpp
@@ -1,4 +1,4 @@
-#include <signal.h>
+#include <csignal>
 #include <systemd/sd-daemon.h>
 
 #include <iostream>
diff --git a/dataplane/memory_manager.cpp b/dataplane/memory_manager.cpp
index f7c35b25..f59ffc45 100644
--- a/dataplane/memory_manager.cpp
+++ b/dataplane/memory_manager.cpp
@@ -68,7 +68,7 @@ common::idp::memory_manager_stats::response memory_manager::memory_manager_stats
 		response_memory_group = root_memory_group;
 		for (const auto& [pointer, memory_pointer] : pointers)
 		{
-			(void)pointer;
+			YANET_GCC_BUG_UNUSED(pointer);
 			response_objects.emplace_back(memory_pointer.name,
 			                              memory_pointer.socket_id,
 			                              memory_pointer.size);
@@ -169,7 +169,7 @@ bool memory_manager::check_memory_limit(const std::string& name,
 
 	for (const auto& [pointer, memory_pointer] : pointers)
 	{
-		(void)pointer;
+		YANET_GCC_BUG_UNUSED(pointer);
 
 		uint64_t object_size = memory_pointer.size;
 		if (memory_pointer.name == name)
@@ -218,7 +218,6 @@ bool memory_manager::check_memory_limit(const std::string& name,
 	return result;
 }
 
-void memory_manager::limits(common::idp::limits::response& response)
+void memory_manager::limits([[maybe_unused]] common::idp::limits::response& response)
 {
-	(void)response;
 }
diff --git a/dataplane/neighbor.cpp b/dataplane/neighbor.cpp
index c27856f6..d0b857b3 100644
--- a/dataplane/neighbor.cpp
+++ b/dataplane/neighbor.cpp
@@ -51,7 +51,7 @@ static void netlink_parse(const std::function<void(const std::string&, const com
 	unsigned int offset = 0;
 	while (offset + sizeof(nlmsghdr) <= buffer_length)
 	{
-		nlmsghdr* nl_message_header = (nlmsghdr*)(buffer + offset);
+		auto* nl_message_header = (nlmsghdr*)(buffer + offset);
 		uint32_t length = nl_message_header->nlmsg_len;
 
 		if (nl_message_header->nlmsg_type == NLMSG_DONE ||
@@ -63,7 +63,7 @@ static void netlink_parse(const std::function<void(const std::string&, const com
 		if (nl_message_header->nlmsg_type == RTM_NEWNEIGH ||
 		    nl_message_header->nlmsg_type == RTM_GETNEIGH)
 		{
-			ndmsg* nl_message = (ndmsg*)NLMSG_DATA(nl_message_header);
+			auto* nl_message = (ndmsg*)NLMSG_DATA(nl_message_header);
 			parse_rt_attributes(rt_attributes,
 			                    NDA_MAX,
 			                    (rtattr*)(((char*)(nl_message)) + NLMSG_ALIGN(sizeof(ndmsg))),
@@ -193,8 +193,7 @@ static void netlink_neighbor_dump(const std::function<void(const std::string&, c
 	close(nl_socket);
 }
 
-module::module() :
-        dataplane(nullptr)
+module::module() :dataplane(nullptr)
 {
 	memset(&stats, 0, sizeof(stats));
 }
@@ -286,7 +285,7 @@ common::idp::neighbor_show::response module::neighbor_show() const
 eResult module::neighbor_insert(const common::idp::neighbor_insert::request& request)
 {
 	const auto& [route_name, interface_name, ip_address, mac_address] = request;
-	(void)route_name; ///< @todo
+	YANET_GCC_BUG_UNUSED(route_name); ///< @todo
 
 	tInterfaceId interface_id = 0;
 	{
@@ -327,7 +326,7 @@ eResult module::neighbor_insert(const common::idp::neighbor_insert::request& req
 		eResult result = eResult::success;
 		for (auto& [socket_id, hashtable_updater] : hashtable.hashtable_updater)
 		{
-			(void)socket_id;
+			YANET_GCC_BUG_UNUSED(socket_id);
 			if (!hashtable_updater.get_pointer()->insert_or_update(key, value))
 			{
 				result = eResult::isFull;
@@ -347,7 +346,7 @@ eResult module::neighbor_insert(const common::idp::neighbor_insert::request& req
 eResult module::neighbor_remove(const common::idp::neighbor_remove::request& request)
 {
 	const auto& [route_name, interface_name, ip_address] = request;
-	(void)route_name; ///< @todo
+	YANET_GCC_BUG_UNUSED(route_name); ///< @todo
 
 	tInterfaceId interface_id = 0;
 	{
@@ -382,7 +381,7 @@ eResult module::neighbor_remove(const common::idp::neighbor_remove::request& req
 		eResult result = eResult::success;
 		for (auto& [socket_id, hashtable_updater] : hashtable.hashtable_updater)
 		{
-			(void)socket_id;
+			YANET_GCC_BUG_UNUSED(socket_id);
 			if (!hashtable_updater.get_pointer()->remove(key))
 			{
 				result = eResult::invalidArguments;
@@ -404,7 +403,7 @@ eResult module::neighbor_clear()
 	auto response = generation_hashtable.update([](neighbor::generation_hashtable& hashtable) {
 		for (auto& [socket_id, hashtable_updater] : hashtable.hashtable_updater)
 		{
-			(void)socket_id;
+			YANET_GCC_BUG_UNUSED(socket_id);
 			hashtable_updater.get_pointer()->clear();
 		}
 		return eResult::success;
@@ -483,7 +482,7 @@ eResult module::neighbor_update_interfaces(const common::idp::neighbor_update_in
 		generation_hashtable.update([this, key, value](neighbor::generation_hashtable& hashtable) {
 			for (auto& [socket_id, hashtable_updater] : hashtable.hashtable_updater)
 			{
-				(void)socket_id;
+				YANET_GCC_BUG_UNUSED(socket_id);
 				if (!hashtable_updater.get_pointer()->insert_or_update(key, value))
 				{
 					stats.hashtable_insert_error++;
@@ -614,7 +613,7 @@ void module::netlink_thread()
 			generation_hashtable.update([this, key, value](neighbor::generation_hashtable& hashtable) {
 				for (auto& [socket_id, hashtable_updater] : hashtable.hashtable_updater)
 				{
-					(void)socket_id;
+					YANET_GCC_BUG_UNUSED(socket_id);
 					if (!hashtable_updater.get_pointer()->insert_or_update(key, value))
 					{
 						stats.hashtable_insert_error++;
@@ -652,7 +651,7 @@ void module::resolve(const dataplane::neighbor::key& key)
 		}
 
 		const auto& [it_route_name, it_interface_name] = it->second;
-		(void)it_route_name;
+		YANET_GCC_BUG_UNUSED(it_route_name);
 
 		interface_name = it_interface_name;
 	}
@@ -677,7 +676,7 @@ void module::resolve(const dataplane::neighbor::key& key)
 	generation_hashtable.update([this, key, value](neighbor::generation_hashtable& hashtable) {
 		for (auto& [socket_id, hashtable_updater] : hashtable.hashtable_updater)
 		{
-			(void)socket_id;
+			YANET_GCC_BUG_UNUSED(socket_id);
 			if (!hashtable_updater.get_pointer()->insert_or_update(key, value))
 			{
 				stats.hashtable_insert_error++;
diff --git a/dataplane/neighbor.h b/dataplane/neighbor.h
index e163862b..554cda23 100644
--- a/dataplane/neighbor.h
+++ b/dataplane/neighbor.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include <map>
-#include <mutex>
 #include <thread>
 #include <unordered_map>
 
diff --git a/dataplane/prepare.h b/dataplane/prepare.h
index 42aed03a..57630cbb 100644
--- a/dataplane/prepare.h
+++ b/dataplane/prepare.h
@@ -64,7 +64,7 @@ inline bool prepareL3(rte_mbuf* mbuf, dataplane::metadata* metadata)
 		uint8_t transport_headerType = ipv6Header->proto;
 		uint16_t transport_headerOffset = metadata->network_headerOffset + sizeof(rte_ipv6_hdr);
 
-		unsigned int extension_i;
+		unsigned int extension_i = 0;
 		for (extension_i = 0;
 		     extension_i < CONFIG_YADECAP_IPV6_EXTENSIONS_MAX + 1;
 		     extension_i++)
diff --git a/dataplane/report.cpp b/dataplane/report.cpp
index 19ebf3e5..3339c625 100644
--- a/dataplane/report.cpp
+++ b/dataplane/report.cpp
@@ -35,9 +35,7 @@ nlohmann::json convertHashtable(const hashtable_mod_T& hashtable, const stats_T&
 
 } // namespace
 
-namespace common
-{
-namespace dregress
+namespace common::dregress
 {
 void to_json(nlohmann::json& j, const stats_t& stats)
 {
@@ -57,8 +55,7 @@ void to_json(nlohmann::json& j, const stats_t& stats)
 	        {"tcp_timeout_sessions", stats.tcp_timeout_sessions},
 	        {"tcp_unknown_sessions", stats.tcp_unknown_sessions}};
 }
-} // namespace dregress
-} // namespace common
+} // namespace common::dregress
 
 cReport::cReport(cDataPlane* dataPlane) :
         dataPlane(dataPlane)
@@ -76,7 +73,7 @@ nlohmann::json cReport::getReport()
 
 	for (const auto& [core_id, worker] : dataPlane->worker_gcs)
 	{
-		(void)core_id;
+		YANET_GCC_BUG_UNUSED(core_id);
 		jsonReport["worker_gcs"].emplace_back(convertWorkerGC(worker));
 	}
 
diff --git a/dataplane/samples.h b/dataplane/samples.h
index 8fbf09d7..dcb05a50 100644
--- a/dataplane/samples.h
+++ b/dataplane/samples.h
@@ -97,7 +97,7 @@ class Sampler
 			return;
 		}
 
-		sample_base_t* sample;
+		sample_base_t* sample = nullptr;
 
 		if (metadata->network_headerType == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4))
 		{
@@ -160,7 +160,7 @@ class Sampler
 		free4 = samples4 + sample4_size - 1;
 	}
 
-	uint64_t get_drops() const
+	[[nodiscard]] uint64_t get_drops() const
 	{
 		return drops;
 	}
@@ -209,7 +209,7 @@ class Sampler
 		return (tcpHeader->tcp_flags & (RTE_TCP_SYN_FLAG | RTE_TCP_ACK_FLAG | RTE_TCP_FIN_FLAG | RTE_TCP_RST_FLAG)) == RTE_TCP_SYN_FLAG;
 	}
 
-	bool is_full() const
+	[[nodiscard]] bool is_full() const
 	{
 		return (void*)(free6 + 1) > (void*)free4;
 	}
@@ -238,4 +238,4 @@ class Sampler
 	};
 };
 
-} //namespace samples
+} // namespace samples
diff --git a/dataplane/sdpserver.h b/dataplane/sdpserver.h
index e224ee92..bebb8efa 100644
--- a/dataplane/sdpserver.h
+++ b/dataplane/sdpserver.h
@@ -1,8 +1,10 @@
 #pragma once
 
+#include <rte_byteorder.h>
+
 #include "common/result.h"
 #include "common/sdpcommon.h"
-#include "type.h"
+#include "common/shared_memory.h"
 
 namespace common::sdp
 {
diff --git a/dataplane/sharedmemory.cpp b/dataplane/sharedmemory.cpp
index 3168fba8..aec56f17 100644
--- a/dataplane/sharedmemory.cpp
+++ b/dataplane/sharedmemory.cpp
@@ -23,7 +23,7 @@ void cSharedMemory::write(rte_mbuf* mbuf, common::globalBase::eFlowType flow_typ
 
 	uint64_t wpos = (buffer.ring->header.before) % buffer.units_number;
 	buffer.ring->header.before++;
-	item_t* item = (item_t*)((uintptr_t)buffer.ring->memory + (wpos * buffer.unit_size));
+	auto* item = (item_t*)((uintptr_t)buffer.ring->memory + (wpos * buffer.unit_size));
 
 	dataplane::metadata* metadata = YADECAP_METADATA(mbuf);
 
diff --git a/dataplane/slow_worker.cpp b/dataplane/slow_worker.cpp
index 6354200f..ccec4452 100644
--- a/dataplane/slow_worker.cpp
+++ b/dataplane/slow_worker.cpp
@@ -1,5 +1,6 @@
 #include "slow_worker.h"
 
+#include "checksum.h"
 #include "common/fallback.h"
 #include "dataplane.h"
 #include "icmp_translations.h"
@@ -422,7 +423,7 @@ bool SlowWorker::handlePacket_fw_state_sync_ingress(rte_mbuf* mbuf)
 		return false;
 	}
 
-	tAclId aclId;
+	tAclId aclId = 0;
 	if (!slow_worker_->dataPlane->controlPlane->fw_state_multicast_acl_ids.apply([&](auto& fw_state_multicast_acl_ids) {
 		    auto it = fw_state_multicast_acl_ids.find(common::ipv6_address_t(ipv6Header->dst_addr));
 		    if (it == fw_state_multicast_acl_ids.end())
@@ -518,10 +519,10 @@ bool SlowWorker::handlePacket_fw_state_sync_ingress(rte_mbuf* mbuf)
 
 			for (auto& [socketId, globalBaseAtomic] : slow_worker_->dataPlane->globalBaseAtomics)
 			{
-				(void)socketId;
+				YANET_GCC_BUG_UNUSED(socketId);
 
-				dataplane::globalBase::fw_state_value_t* lookup_value;
-				dataplane::spinlock_nonrecursive_t* locker;
+				dataplane::globalBase::fw_state_value_t* lookup_value = nullptr;
+				dataplane::spinlock_nonrecursive_t* locker = nullptr;
 				const uint32_t hash = globalBaseAtomic->fw6_state->lookup(key, lookup_value, locker);
 				if (lookup_value)
 				{
@@ -599,10 +600,10 @@ bool SlowWorker::handlePacket_fw_state_sync_ingress(rte_mbuf* mbuf)
 
 			for (auto& [socketId, globalBaseAtomic] : slow_worker_->dataPlane->globalBaseAtomics)
 			{
-				(void)socketId;
+				YANET_GCC_BUG_UNUSED(socketId);
 
-				dataplane::globalBase::fw_state_value_t* lookup_value;
-				dataplane::spinlock_nonrecursive_t* locker;
+				dataplane::globalBase::fw_state_value_t* lookup_value = nullptr;
+				dataplane::spinlock_nonrecursive_t* locker = nullptr;
 				const uint32_t hash = globalBaseAtomic->fw4_state->lookup(key, lookup_value, locker);
 				if (lookup_value)
 				{
@@ -636,7 +637,7 @@ void SlowWorker::BalancerICMPForwardCriticalSection(
 
 	common::ip_address_t original_src_from_icmp_payload;
 	common::ip_address_t src_from_ip_header;
-	uint16_t original_src_port_from_icmp_payload;
+	uint16_t original_src_port_from_icmp_payload = 0;
 
 	uint32_t balancer_id = metadata->flow.data.balancer.id;
 
diff --git a/dataplane/sock_dev.cpp b/dataplane/sock_dev.cpp
index e2cba99d..3b852c17 100644
--- a/dataplane/sock_dev.cpp
+++ b/dataplane/sock_dev.cpp
@@ -98,7 +98,7 @@ sock_dev_stop(struct rte_eth_dev* dev)
 static int
 sock_dev_close(struct rte_eth_dev* dev)
 {
-	struct sock_internals* internals =
+	auto* internals =
 	        (struct sock_internals*)dev->data->dev_private;
 
 	close(internals->fd);
@@ -143,7 +143,7 @@ sock_dev_rx_queue_setup(struct rte_eth_dev* dev,
                         const struct rte_eth_rxconf* rx_conf __rte_unused,
                         struct rte_mempool* mb_pool)
 {
-	struct sock_internals* si = (struct sock_internals*)dev->data->dev_private;
+	auto* si = (struct sock_internals*)dev->data->dev_private;
 	dev->data->rx_queues[rx_queue_id] = si->rx_queues + rx_queue_id;
 	si->rx_queues[rx_queue_id].internals = si;
 	si->rx_queues[rx_queue_id].mb_pool = mb_pool;
@@ -257,11 +257,11 @@ sock_dev_rx(void* q, struct rte_mbuf** bufs, uint16_t nb_bufs)
 		return 0;
 	}
 
-	struct sock_queue* sq = (struct sock_queue*)q;
+	auto* sq = (struct sock_queue*)q;
 
 	if (sq->internals->conFd < 0)
 	{
-		sq->internals->conFd = accept4(sq->internals->fd, NULL, NULL, SOCK_NONBLOCK);
+		sq->internals->conFd = accept4(sq->internals->fd, nullptr, nullptr, SOCK_NONBLOCK);
 	}
 
 	if (sq->internals->conFd < 0)
@@ -297,9 +297,9 @@ sock_dev_rx(void* q, struct rte_mbuf** bufs, uint16_t nb_bufs)
 		}
 	} while (rc == 0); /// Repeat if there is no data yet
 
-	struct rte_mbuf* mbuf;
+	struct rte_mbuf* mbuf = nullptr;
 	mbuf = rte_pktmbuf_alloc(sq->mb_pool);
-	if (unlikely(mbuf == NULL))
+	if (unlikely(mbuf == nullptr))
 	{
 		sq->internals->eth_stats.ierrors++;
 		return 0;
@@ -365,7 +365,7 @@ sock_dev_tx(void* q, struct rte_mbuf** bufs, uint16_t nb_bufs)
 		return 0;
 	}
 
-	struct sock_internals* si = (struct sock_internals*)q;
+	auto* si = (struct sock_internals*)q;
 	if (si->conFd < 0)
 	{
 		si->eth_stats.oerrors++;
@@ -386,7 +386,7 @@ sock_dev_tx(void* q, struct rte_mbuf** bufs, uint16_t nb_bufs)
 		iov[0].iov_base = &hdr;
 		iov[0].iov_len = sizeof(hdr);
 
-		iov[1].iov_base = (void*)rte_pktmbuf_read(mbuf, 0, len, writeBuf);
+		iov[1].iov_base = const_cast<void*>(rte_pktmbuf_read(mbuf, 0, len, writeBuf));
 		iov[1].iov_len = len;
 
 		if (writeIovCount(si->conFd, iov, 2) < 0)
@@ -406,16 +406,16 @@ sock_dev_tx(void* q, struct rte_mbuf** bufs, uint16_t nb_bufs)
 int sock_dev_stats_get(struct rte_eth_dev* dev,
                        struct rte_eth_stats* igb_stats)
 {
-	sock_internals* private_data = (struct sock_internals*)dev->data->dev_private;
+	auto* private_data = (struct sock_internals*)dev->data->dev_private;
 	memcpy(igb_stats, &private_data->eth_stats, sizeof(rte_eth_stats));
 	return 0;
 }
 
 int sock_dev_create(const char* path, const char* name, uint8_t numa_node)
 {
-	struct sock_internals* internals = (struct sock_internals*)
+	auto* internals = (struct sock_internals*)
 	        rte_zmalloc_socket(path, sizeof(struct sock_internals), 0, numa_node);
-	if (internals == NULL)
+	if (internals == nullptr)
 		return ENOSPC;
 
 	internals->pci_id.device_id = 0xBEEF;
@@ -452,9 +452,9 @@ int sock_dev_create(const char* path, const char* name, uint8_t numa_node)
 	listen(internals->fd, 1);
 	internals->conFd = -1;
 
-	struct rte_eth_dev* eth_dev = NULL;
+	struct rte_eth_dev* eth_dev = nullptr;
 	eth_dev = rte_eth_dev_allocate(name);
-	if (eth_dev == NULL)
+	if (eth_dev == nullptr)
 	{
 		close(internals->fd);
 		unlink(internals->sockaddr.sun_path);
diff --git a/dataplane/sock_dev.h b/dataplane/sock_dev.h
index 020759cc..290cbe06 100644
--- a/dataplane/sock_dev.h
+++ b/dataplane/sock_dev.h
@@ -3,7 +3,7 @@
 #include <cstdint>
 #include <string>
 
-//#define SOCK_DEV_PREFIX "sock_dev:"
+// #define SOCK_DEV_PREFIX "sock_dev:"
 using namespace std::string_literals;
 const std::string SOCK_DEV_PREFIX = "sock_dev:"s;
 
diff --git a/dataplane/type.h b/dataplane/type.h
index b82ffa82..cf55b213 100644
--- a/dataplane/type.h
+++ b/dataplane/type.h
@@ -1,10 +1,8 @@
 #pragma once
 
-#include <rte_byteorder.h>
 #include <rte_ether.h>
 
 #include "common/balancer.h"
-#include "common/config.h"
 #include "common/scheduler.h"
 #include "common/type.h"
 
@@ -191,7 +189,7 @@ struct ipv6_address_t
 		return !(*this == second);
 	}
 
-	bool empty() const ///< @todo: is_default()
+	[[nodiscard]] bool empty() const ///< @todo: is_default()
 	{
 		for (auto b : bytes)
 		{
@@ -301,8 +299,7 @@ struct tInterface
 
 struct nat64stateful_t
 {
-	nat64stateful_t() :
-	        pool_size(0)
+	nat64stateful_t()
 	{
 		state_timeout.tcp_syn = YANET_CONFIG_STATE_TIMEOUT_DEFAULT;
 		state_timeout.tcp_ack = YANET_CONFIG_STATE_TIMEOUT_DEFAULT;
@@ -315,7 +312,7 @@ struct nat64stateful_t
 	/// @todo: uint8_t enabled;
 
 	uint32_t pool_start;
-	uint32_t pool_size;
+	uint32_t pool_size{};
 	tCounterId counter_id;
 	uint8_t ipv4_dscp_flags;
 	struct
@@ -405,12 +402,9 @@ static_assert(YANET_CONFIG_COUNTERS_SIZE <= 0xFFFFFF, "invalid YANET_CONFIG_COUN
 
 struct route_value_t
 {
-	route_value_t() :
-	        type(common::globalBase::eNexthopType::controlPlane)
-	{
-	}
+	route_value_t() = default;
 
-	common::globalBase::eNexthopType type; ///< @todo: DELETE
+	common::globalBase::eNexthopType type{common::globalBase::eNexthopType::controlPlane}; ///< @todo: DELETE
 
 	union
 	{
@@ -425,12 +419,9 @@ struct route_value_t
 
 struct route_tunnel_value_t
 {
-	route_tunnel_value_t() :
-	        type(common::globalBase::eNexthopType::controlPlane)
-	{
-	}
+	route_tunnel_value_t() = default;
 
-	common::globalBase::eNexthopType type; ///< @todo: DELETE
+	common::globalBase::eNexthopType type{common::globalBase::eNexthopType::controlPlane}; ///< @todo: DELETE
 
 	union
 	{
@@ -590,9 +581,9 @@ struct balancer_service_t
 	uint32_t wlc_power;
 
 	/*
-		outer_source_network_flag:
-		zero byte stores the state for ipv4_router_source_network
-		first byte stores the state for ipv6_router_source_network
+	        outer_source_network_flag:
+	        zero byte stores the state for ipv4_router_source_network
+	        first byte stores the state for ipv6_router_source_network
 	*/
 	uint8_t outer_source_network_flag;
 	ipv4_prefix_t ipv4_outer_source_network;
@@ -651,7 +642,7 @@ struct fw_tcp_state_value_t
 	uint8_t src_flags : 4;
 	uint8_t dst_flags : 4;
 
-	uint8_t pack() const
+	[[nodiscard]] uint8_t pack() const
 	{
 		return src_flags | (dst_flags << 4);
 	}
@@ -739,7 +730,7 @@ struct fw_state_sync_frame_t
 	uint32_t flow_id6;
 	uint32_t extra;
 
-	static inline fw_state_sync_frame_t from_state_key(const fw4_state_key_t& key)
+	static fw_state_sync_frame_t from_state_key(const fw4_state_key_t& key)
 	{
 		fw_state_sync_frame_t sync_frame{};
 		sync_frame.proto = uint8_t(key.proto);
@@ -752,7 +743,7 @@ struct fw_state_sync_frame_t
 		return sync_frame;
 	}
 
-	static inline fw_state_sync_frame_t from_state_key(const fw6_state_key_t& key)
+	static fw_state_sync_frame_t from_state_key(const fw6_state_key_t& key)
 	{
 		fw_state_sync_frame_t sync_frame{};
 		sync_frame.proto = uint8_t(key.proto);
diff --git a/dataplane/unittest/hashtable.cpp b/dataplane/unittest/hashtable.cpp
index 92d2311c..78381e00 100644
--- a/dataplane/unittest/hashtable.cpp
+++ b/dataplane/unittest/hashtable.cpp
@@ -10,7 +10,7 @@ TEST(HashtableTest, Basic)
 {
 	dataplane::hashtable_chain_t<int, int, 128, 128, 4, 4> t;
 
-	int* v;
+	int* v = nullptr;
 	int k = 1;
 	t.lookup(&k, &v, 1);
 	EXPECT_EQ(nullptr, v);
@@ -42,8 +42,8 @@ TEST(HashtableTest, Extended)
 
 	for (int k = 0; k < 512; ++k)
 	{
-		int* v;
-		dataplane::spinlock_t* locker;
+		int* v = nullptr;
+		dataplane::spinlock_t* locker = nullptr;
 
 		t.lookup(k, v, locker);
 		if ((k % 7) && (k % 11))
@@ -220,47 +220,37 @@ TEST(hashtable_mod_id32, burst)
 	{
 		const auto mask = ht.lookup(hashes, keys, values, YANET_CONFIG_BURST_SIZE);
 		EXPECT_EQ(0, mask);
-		for (unsigned int i = 0;
-		     i < YANET_CONFIG_BURST_SIZE;
-		     i++)
+		for (unsigned int value : values)
 		{
-			EXPECT_EQ(0x80000000, values[i] & (1u << 31));
+			EXPECT_EQ(0x80000000, value & (1u << 31));
 		}
 	}
 
-	for (unsigned int i = 0;
-	     i < YANET_CONFIG_BURST_SIZE;
-	     i++)
+	for (auto key : keys)
 	{
-		EXPECT_EQ(eResult::success, ht.insert(updater, keys[i], value1));
+		EXPECT_EQ(eResult::success, ht.insert(updater, key, value1));
 	}
 
 	{
 		const auto mask = ht.lookup(hashes, keys, values, YANET_CONFIG_BURST_SIZE);
 		EXPECT_EQ(0xFFFFFFFF, mask);
-		for (unsigned int i = 0;
-		     i < YANET_CONFIG_BURST_SIZE;
-		     i++)
+		for (unsigned int value : values)
 		{
-			EXPECT_EQ(value1, values[i]);
+			EXPECT_EQ(value1, value);
 		}
 	}
 
-	for (unsigned int i = 0;
-	     i < YANET_CONFIG_BURST_SIZE;
-	     i++)
+	for (auto key : keys)
 	{
-		EXPECT_EQ(eResult::success, ht.insert(updater, keys[i], value2));
+		EXPECT_EQ(eResult::success, ht.insert(updater, key, value2));
 	}
 
 	{
 		const auto mask = ht.lookup(hashes, keys, values, YANET_CONFIG_BURST_SIZE);
 		EXPECT_EQ(0xFFFFFFFF, mask);
-		for (unsigned int i = 0;
-		     i < YANET_CONFIG_BURST_SIZE;
-		     i++)
+		for (unsigned int value : values)
 		{
-			EXPECT_EQ(value2, values[i]);
+			EXPECT_EQ(value2, value);
 		}
 	}
 
@@ -269,11 +259,9 @@ TEST(hashtable_mod_id32, burst)
 	{
 		const auto mask = ht.lookup(hashes, keys, values, YANET_CONFIG_BURST_SIZE);
 		EXPECT_EQ(0, mask);
-		for (unsigned int i = 0;
-		     i < YANET_CONFIG_BURST_SIZE;
-		     i++)
+		for (unsigned int value : values)
 		{
-			EXPECT_EQ(0x80000000, values[i] & (1u << 31));
+			EXPECT_EQ(0x80000000, value & (1u << 31));
 		}
 	}
 }
@@ -338,8 +326,8 @@ TEST(hashtable_mod_spinlock, basic)
 	const uint32_t value1 = 12345u;
 	const uint32_t value2 = 12345678u;
 
-	uint32_t* value;
-	dataplane::spinlock_nonrecursive_t* locker;
+	uint32_t* value = nullptr;
+	dataplane::spinlock_nonrecursive_t* locker = nullptr;
 
 	{
 		const uint32_t hash = ht.lookup(key, value, locker);
@@ -415,8 +403,8 @@ TEST(hashtable_mod_spinlock, collision)
 	                                  32>
 	        ht;
 
-	uint32_t* value;
-	dataplane::spinlock_nonrecursive_t* locker;
+	uint32_t* value = nullptr;
+	dataplane::spinlock_nonrecursive_t* locker = nullptr;
 
 	for (unsigned int i = 0;
 	     i < 64;
diff --git a/dataplane/unittest/ip_address.cpp b/dataplane/unittest/ip_address.cpp
index 0fcf9fec..aad01afa 100644
--- a/dataplane/unittest/ip_address.cpp
+++ b/dataplane/unittest/ip_address.cpp
@@ -21,7 +21,7 @@ TEST(IpAddress, Basic)
 
 	{
 		ipv6_address_t addr = ipv6_address_t::convert(commonAddr);
-		ipv6_address_t expected{0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8};
+		ipv6_address_t expected{{{0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8}}};
 		EXPECT_EQ(addr, expected);
 
 		addr.reset();
diff --git a/dataplane/unittest/lpm.cpp b/dataplane/unittest/lpm.cpp
deleted file mode 100644
index bd83afc7..00000000
--- a/dataplane/unittest/lpm.cpp
+++ /dev/null
@@ -1,890 +0,0 @@
-//! In this LPM insertion order matters!
-
-#include <cctype>
-#include <fstream>
-#include <string>
-
-#include <gtest/gtest.h>
-
-#include "../lpm.h"
-
-namespace
-{
-
-/// Non-functional extension of an LPM to provide nice dump methods.
-template<uint32_t TExtendedSize>
-class lpm6_8x16bit_atomic : public dataplane::lpm6_8x16bit_atomic<TExtendedSize>
-{
-public:
-	void print() const
-	{
-		auto envPtr = std::getenv("YANET_TEST_DEBUG");
-		if (envPtr == nullptr)
-		{
-			return;
-		}
-
-		std::string env(envPtr);
-		if (env == "plain")
-		{
-			print_table();
-			return;
-		}
-		if (env == "graph")
-		{
-			print_digraph();
-			return;
-		}
-	}
-
-	void print_table() const
-	{
-		printf("==================================\n");
-		print_chunk(this->rootChunk, -1, true);
-		for (unsigned int j = 0; j < TExtendedSize; j++)
-		{
-			print_chunk(this->extendedChunks[j], j);
-		}
-	}
-
-	void print_digraph() const
-	{
-		printf("%s\n", digraph().data());
-	}
-
-	std::string digraph() const
-	{
-		std::ostringstream s;
-		s << "digraph G {\n";
-		s << "  nodesep=.05;\n";
-		s << "  rankdir=LR;\n";
-		s << "  node [shape=record fontname=\"Monospace\" fontsize=10];\n";
-		s << "  node [width = 0.5];\n";
-		build_digraph_chunk(this->rootChunk, "R", s, true);
-		for (unsigned int j = 0; j < TExtendedSize; j++)
-		{
-			build_digraph_chunk(this->extendedChunks[j], j, s);
-		}
-		s << "}\n";
-
-		return s.str();
-	}
-
-private:
-	struct entry_t
-	{
-		int from;
-		int to;
-		uint32_t flags;
-		uint32_t value;
-	};
-
-	template<typename T, typename F>
-	void visit_chunk(const T& chunk, bool isRoot, const F& fn) const
-	{
-		if (!(chunk.entries[0].flags & this->flagExtendedChunkOccupied) && !isRoot)
-		{
-			return;
-		}
-
-		int minDupIdx = 0;
-		for (int i = 1; i < 256 * 256; i++)
-		{
-			auto currEntry = chunk.entries[i];
-			currEntry.flags &= ~(this->flagExtendedChunkOccupied);
-			auto prevEntry = chunk.entries[i - 1];
-			prevEntry.flags &= ~(this->flagExtendedChunkOccupied);
-			auto minDupIdxEntry = chunk.entries[minDupIdx];
-			minDupIdxEntry.flags &= ~(this->flagExtendedChunkOccupied);
-
-			if (currEntry.atomic != prevEntry.atomic)
-			{
-				if (minDupIdxEntry.atomic != 0)
-				{
-					fn(entry_t{minDupIdx, i - 1, minDupIdxEntry.flags, minDupIdxEntry.valueId});
-				}
-				minDupIdx = i;
-			}
-		}
-		if (chunk.entries[minDupIdx].atomic != 0)
-		{
-			fn(entry_t{minDupIdx, 0xffff, chunk.entries[minDupIdx].flags, chunk.entries[minDupIdx].valueId});
-		}
-	}
-
-	template<typename T>
-	void print_chunk(const T& chunk, int chunkId, bool isRoot = false) const
-	{
-		visit_chunk(chunk, isRoot, [&](entry_t entry) {
-			if (entry.from == entry.to)
-			{
-				printf("%2d %04x      : flags=0x%02x, value=%d\n", chunkId, entry.from, entry.flags, entry.value);
-			}
-			else
-			{
-				printf("%2d %04x..%04x: flags=0x%02x, value=%d\n", chunkId, entry.from, entry.to, entry.flags, entry.value);
-			}
-		});
-	}
-
-	template<typename T, typename N>
-	void build_digraph_chunk(const T& chunk, N j, std::ostringstream& s, bool isRoot = false) const
-	{
-		std::vector<entry_t> entries;
-		visit_chunk(chunk, isRoot, [&](entry_t entry) {
-			entries.push_back(entry);
-		});
-
-		if (!entries.empty())
-		{
-			s << "  node" << j << "[label=\"<n>[" << j << "]|{{";
-			for (auto p = entries.begin(); p != entries.end(); ++p)
-			{
-				if (p->from == p->to)
-				{
-					char buf[16] = {};
-					std::snprintf(buf, 8, "%04x", p->from);
-					s << buf;
-				}
-				else
-				{
-					char buf[16] = {};
-					std::snprintf(buf, 12, "%04x-%04x", p->from, p->to);
-					s << buf;
-				}
-				if (p != entries.end() - 1)
-				{
-					s << "|";
-				}
-			}
-			s << "}|{";
-			for (unsigned int i = 0; i < entries.size(); ++i)
-			{
-				s << "<f" << i << ">";
-				if (entries[i].flags & this->flagValid)
-				{
-					s << entries[i].value;
-				}
-				if (i != entries.size() - 1)
-				{
-					s << "|";
-				}
-			}
-			s << "}}\"];\n";
-
-			for (unsigned int i = 0; i < entries.size(); ++i)
-			{
-				if (entries[i].flags & this->flagExtended)
-				{
-					s << "  node" << j << ":f" << i << "->node" << entries[i].value << ":n\n";
-				}
-			}
-		}
-	}
-};
-
-TEST(LPM, Lookup)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	uint32_t valueId{0};
-	EXPECT_FALSE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::1"), &valueId));
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("2222:777:aabc:1234::"), 64, 4299));
-
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::1"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:ffff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	t->print();
-}
-
-TEST(LPM, LookupUnalignedBitMask)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("2222:777:aabc:1234::"), 69, 4299));
-
-	uint32_t valueId{0};
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:07ff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	// Out of range.
-	EXPECT_FALSE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:800:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(dataplane::lpmValueIdInvalid, valueId);
-
-	t->print();
-}
-
-TEST(LPM, LookupOverlapped)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("2222:777:aabc:1234::"), 64, 4299));
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("2222:777:aabc:1234:4800::"), 69, 589));
-
-	uint32_t valueId{0};
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:47ff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:4800::"), &valueId));
-	EXPECT_EQ(589, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:4fff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(589, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:5000:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:ffff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	t->print();
-}
-
-TEST(LPM, LookupOverlappedSimple)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	const std::vector<std::tuple<std::string, uint8_t, uint32_t>> entries{
-	        {"::", 0, 1},
-	        {"10:20::", 32, 2},
-	};
-
-	for (auto [net, mask, value] : entries)
-	{
-		EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t(net), mask, value));
-	}
-
-	uint32_t valueId{0};
-
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("::1"), &valueId));
-	EXPECT_EQ(1, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("10:20::1"), &valueId));
-	EXPECT_EQ(2, valueId);
-
-	t->print();
-}
-
-TEST(LPM, LookupExtMask)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	uint32_t valueId{0};
-	EXPECT_FALSE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::1"), &valueId));
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("2222:777:aabc:1234::"), common::ipv6_address_t("ffff:ffff:ffff:ffff::"), 4299));
-
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::1"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:ffff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	t->print();
-}
-
-TEST(LPM, LookupUnalignedBitExtMask)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("2222:777:aabc:1234::"), common::ipv6_address_t("ffff:ffff:ffff:ffff:f800::"), 4299));
-
-	uint32_t valueId{0};
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:07ff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	// Out of range.
-	EXPECT_FALSE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:800:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(dataplane::lpmValueIdInvalid, valueId);
-
-	t->print();
-}
-
-TEST(LPM, LookupOverlappedExt)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	const std::vector<std::tuple<std::string, std::string, uint32_t>> entries{
-	        {"2222:777:aabc:1234::", "ffff:ffff:ffff:ffff::", 4299},
-	        {"2222:777:aabc:1234:4800::", "ffff:ffff:ffff:ffff:f800::", 589},
-	};
-
-	for (auto [net, mask, value] : entries)
-	{
-		EXPECT_EQ(t->insert(common::ipv6_address_t(net), common::ipv6_address_t(mask), value), eResult::success);
-		t->print();
-	}
-
-	uint32_t valueId{0};
-
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234::"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:47ff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:4800::"), &valueId));
-	EXPECT_EQ(589, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:4fff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(589, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:5000::"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:ffff:ffff:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	t->print();
-}
-
-TEST(LPM, LookupProjectIDExtMask)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<128>>();
-
-	uint32_t valueId{0};
-	EXPECT_FALSE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:0:1234:0:1"), &valueId));
-
-	// 1234@2222:777:aabc::/48
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("2222:777:aabc::1234:0:0"), common::ipv6_address_t("ffff:ffff:ffff:0:ffff:ffff::"), 4299));
-
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:0:1234:0:1"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:0:1234::"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:0:1234:ffff:ffff"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_FALSE(t->lookup(common::ipv6_address_t("2222:777:aabc:1234:0:1233::"), &valueId));
-	EXPECT_EQ(dataplane::lpmValueIdInvalid, valueId);
-
-	t->print();
-}
-
-TEST(LPM, LookupManyProjectIDsExtMask)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	const std::vector<std::tuple<std::string, std::string, uint32_t>> entries{
-	        {"2222:777:aabc::1234:0:0", "ffff:ffff:ffff:0:ffff:ffff::", 100},
-	        {"2222:777:aabc::1122:0:0", "ffff:ffff:ffff:0:ffff:ffff::", 101},
-	        {"2222:777:ff1d::", "ffff:ffff:ffff::", 102},
-	        {"2222:777:c00:0:add:8765::", "ffff:ffff:ff00:0:ffff:ffff::", 103},
-	        {"2222:777:c00:0:add:8005::", "ffff:ffff:ff00:0:ffff:ffff::", 104},
-	        {"2222:770:c00::f800:0:0", "ffff:ffff:ff00:0:ffff:f800::", 105},
-	};
-
-	for (auto [net, mask, value] : entries)
-	{
-		EXPECT_EQ(t->insert(common::ipv6_address_t(net), common::ipv6_address_t(mask), value), eResult::success);
-	}
-
-	const std::vector<std::tuple<std::string, uint32_t>> cases{
-	        /// Value 100
-	        {"2222:777:aabc:1234:0:1234::", 100},
-	        {"2222:777:aabc:1234:0:1234:0:1", 100},
-	        {"2222:777:aabc:1234:0:1234::", 100},
-	        {"2222:777:aabc:1234:0:1234:0:ffff", 100},
-	        {"2222:777:aabc:1234:0:1234:ffff:ffff", 100},
-
-	        /// Value 101
-	        {"2222:777:aabc::1122:0:0", 101},
-	        {"2222:777:aabc::1122:0:1", 101},
-	        {"2222:777:aabc:ff00:0:1122:0:1", 101},
-	        {"2222:777:aabc:ffff:0:1122:0:1", 101},
-
-	        /// Value 102
-	        {"2222:777:ff1d::1", 102},
-	        {"2222:777:ff1d:ff00::1", 102},
-	        {"2222:777:ff1d:ff00:0:1234:0:1", 102},
-
-	        /// Value 103
-	        {"2222:777:c00:0:add:8765::", 103},
-	        {"2222:777:c00:0:add:8765:0:1", 103},
-	        {"2222:777:c00:0:add:8765:0:2211", 103},
-	        {"2222:777:c00:0:add:8765:4433:0", 103},
-	        {"2222:777:c77:6655:add:8765:4433:2211", 103},
-
-	        /// Value 104
-	        {"2222:777:c00:0:add:8005::", 104},
-	        {"2222:777:c00:0:add:8005:0:1", 104},
-	        {"2222:777:c00:0:add:8005:0:2211", 104},
-	        {"2222:777:c00:0:add:8005:4433:0", 104},
-	        {"2222:777:c77:6655:add:8005:4433:2211", 104},
-
-	        /// Value 105
-	        {"2222:770:c00::f800:0:0", 105},
-	        {"2222:770:c00::f800:0:11", 105},
-	        {"2222:770:c00::f800:4433:2211", 105},
-	        {"2222:770:c00::f900:4433:2211", 105},
-	        {"2222:770:c00::ff00:4433:2211", 105},
-	        {"2222:770:c00::ff01:4433:2211", 105},
-	        {"2222:770:c00::fffe:4433:2211", 105},
-	        {"2222:770:c00::ffff:4433:2211", 105},
-	        {"2222:770:c00:8877:0:ffff:4433:2211", 105},
-	        {"2222:770:c99:8877:0:ffff:4433:2211", 105},
-
-	        /// Invalid
-	        {"2222:777:aabc::1134:0:1", dataplane::lpmValueIdInvalid},
-	        {"2222:777:ff1f::1234:0:1", dataplane::lpmValueIdInvalid},
-	        {"2222:770:c00::f7ff:4433:2211", dataplane::lpmValueIdInvalid},
-	};
-
-	for (auto [addr, value] : cases)
-	{
-		uint32_t valueId{0};
-		EXPECT_EQ(value != dataplane::lpmValueIdInvalid, t->lookup(common::ipv6_address_t(addr), &valueId));
-		EXPECT_EQ(value, valueId);
-	}
-
-	t->print();
-}
-
-TEST(LPM, LookupTrouble)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	const std::vector<std::tuple<std::string, std::string, uint32_t>> entries{
-	        {"2222:777:aabc:2030::", "ffff:ffff:ffff:fff0::", 589},
-	        {"2222:777:aabc:2030::", "ffff:ffff:ffff:ffff::", 42},
-	        {"2222:777:aabc:2030:0:1234::", "ffff:ffff:ffff:fff0:ffff:ffff::", 4299},
-	        {"2222:777:aabc:2030:0:5678::", "ffff:ffff:ffff:fff0:ffff:ffff::", 4298},
-	        {"2222:777:aabc:2030:aabb:5678::", "ffff:ffff:ffff:fff0:ffff:ffff::", 4297},
-	};
-
-	for (auto [net, mask, value] : entries)
-	{
-		EXPECT_EQ(t->insert(common::ipv6_address_t(net), common::ipv6_address_t(mask), value), eResult::success);
-		t->print();
-	}
-
-	const std::vector<std::tuple<std::string, uint32_t>> cases{
-	        {"2222:777:aabc:2030::1", 42},
-	        {"2222:777:aabc:2030:0:0:ffff:1", 42},
-	        {"2222:777:aabc:2030:0:ffff:0:1", 42},
-	        {"2222:777:aabc:2030:0:ffff:ffff:1", 42},
-	        {"2222:777:aabc:2030:aabb:ffff:ffff:1", 42},
-
-	        {"2222:777:aabc:2031::1", 589},
-	        {"2222:777:aabc:2032::1", 589},
-	        {"2222:777:aabc:2033::1", 589},
-	        {"2222:777:aabc:2034::1", 589},
-	        {"2222:777:aabc:2035::1", 589},
-	        {"2222:777:aabc:2036::1", 589},
-	        {"2222:777:aabc:2037::1", 589},
-	        {"2222:777:aabc:2038::1", 589},
-	        {"2222:777:aabc:2039::1", 589},
-	        {"2222:777:aabc:203a::1", 589},
-	        {"2222:777:aabc:203b::1", 589},
-	        {"2222:777:aabc:203c::1", 589},
-	        {"2222:777:aabc:203d::1", 589},
-	        {"2222:777:aabc:203e::1", 589},
-	        {"2222:777:aabc:203f::1", 589},
-	        {"2222:777:aabc:2031:0:0:ffff:1", 589},
-	        {"2222:777:aabc:2032:0:ffff:0:1", 589},
-	        {"2222:777:aabc:2033:0:ffff:ffff:1", 589},
-	        {"2222:777:aabc:2034:aabb:ffff:ffff:1", 589},
-
-	        {"2222:777:aabc:2030:0:1234:0:1", 4299},
-	        {"2222:777:aabc:2031:0:1234:0:1", 4299},
-	        {"2222:777:aabc:2032:0:1234:0:1", 4299},
-	        {"2222:777:aabc:2033:0:1234:0:1", 4299},
-	        {"2222:777:aabc:2034:0:1234:0:1", 4299},
-	        {"2222:777:aabc:2035:0:1234:0:1", 4299},
-	        {"2222:777:aabc:2036:0:1234:0:1", 4299},
-	        {"2222:777:aabc:2037:0:1234:0:1", 4299},
-	        {"2222:777:aabc:2038:0:1234:0:1", 4299},
-	        {"2222:777:aabc:2039:0:1234:0:1", 4299},
-	        {"2222:777:aabc:203a:0:1234:0:1", 4299},
-	        {"2222:777:aabc:203b:0:1234:0:1", 4299},
-	        {"2222:777:aabc:203c:0:1234:0:1", 4299},
-	        {"2222:777:aabc:203d:0:1234:0:1", 4299},
-	        {"2222:777:aabc:203e:0:1234:0:1", 4299},
-	        {"2222:777:aabc:203f:0:1234:0:1", 4299},
-
-	        {"2222:777:aabc:2030:0:5678:0:1", 4298},
-	        {"2222:777:aabc:2031:0:5678:0:1", 4298},
-	        {"2222:777:aabc:2032:0:5678:0:1", 4298},
-	        {"2222:777:aabc:2033:0:5678:0:1", 4298},
-	        {"2222:777:aabc:2034:0:5678:0:1", 4298},
-	        {"2222:777:aabc:2035:0:5678:0:1", 4298},
-	        {"2222:777:aabc:2036:0:5678:0:1", 4298},
-	        {"2222:777:aabc:2037:0:5678:0:1", 4298},
-	        {"2222:777:aabc:2038:0:5678:0:1", 4298},
-	        {"2222:777:aabc:2039:0:5678:0:1", 4298},
-	        {"2222:777:aabc:203a:0:5678:0:1", 4298},
-	        {"2222:777:aabc:203b:0:5678:0:1", 4298},
-	        {"2222:777:aabc:203c:0:5678:0:1", 4298},
-	        {"2222:777:aabc:203d:0:5678:0:1", 4298},
-	        {"2222:777:aabc:203e:0:5678:0:1", 4298},
-	        {"2222:777:aabc:203f:0:5678:0:1", 4298},
-
-	        {"2222:777:aabc:2030:aabb:5678::1", 4297},
-	        {"2222:777:aabc:2031:aabb:5678::1", 4297},
-	        {"2222:777:aabc:2032:aabb:5678::1", 4297},
-	        {"2222:777:aabc:2033:aabb:5678::1", 4297},
-	        {"2222:777:aabc:2034:aabb:5678::1", 4297},
-	        {"2222:777:aabc:2035:aabb:5678::1", 4297},
-	        {"2222:777:aabc:2036:aabb:5678::1", 4297},
-	        {"2222:777:aabc:2037:aabb:5678::1", 4297},
-	        {"2222:777:aabc:2038:aabb:5678::1", 4297},
-	        {"2222:777:aabc:2039:aabb:5678::1", 4297},
-	        {"2222:777:aabc:203a:aabb:5678::1", 4297},
-	        {"2222:777:aabc:203b:aabb:5678::1", 4297},
-	        {"2222:777:aabc:203c:aabb:5678::1", 4297},
-	        {"2222:777:aabc:203d:aabb:5678::1", 4297},
-	        {"2222:777:aabc:203e:aabb:5678::1", 4297},
-	        {"2222:777:aabc:203f:aabb:5678::1", 4297},
-	};
-
-	for (auto [addr, value] : cases)
-	{
-		uint32_t valueId{0};
-		EXPECT_EQ(value != dataplane::lpmValueIdInvalid, t->lookup(common::ipv6_address_t(addr), &valueId));
-		EXPECT_EQ(value, valueId) << common::ipv6_address_t(addr).toString() << " -> " << value;
-	}
-
-	t->print();
-}
-
-TEST(LPM, LookupMixedNetworksWithSamePrefix)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	const std::vector<std::tuple<std::string, std::string, uint32_t>> entries{
-	        {"2222:777:c00::", "ffff:ffff:ff00::", 589},
-	        {"2222:777:c00:0:add:8765::", "ffff:ffff:ff00:0:ffff:ffff::", 4299},
-	};
-
-	for (auto [net, mask, value] : entries)
-	{
-		EXPECT_EQ(t->insert(common::ipv6_address_t(net), common::ipv6_address_t(mask), value), eResult::success);
-	}
-
-	const std::vector<std::tuple<std::string, uint32_t>> cases{
-	        {"2222:777:c00:0:add:8765:0:1", 4299},
-	        {"2222:777:c00:0:10d:4d60:0:1", 589},
-	};
-
-	for (auto [addr, value] : cases)
-	{
-		uint32_t valueId{0};
-		EXPECT_EQ(value != dataplane::lpmValueIdInvalid, t->lookup(common::ipv6_address_t(addr), &valueId));
-		EXPECT_EQ(value, valueId);
-	}
-
-	t->print();
-}
-
-TEST(LPM, LookupSummary)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	const std::vector<std::tuple<std::string, std::string, uint32_t>> entries{
-	        {"::", "::", 1001},
-	        {"1111:2222::", "ffff:ffff::", 1002},
-	        {"3333:4444:5555::", "ffff:ffff:ffff::", 1003},
-	        {"3333:4444:5555:0:aaaa:bbbb::", "ffff:ffff:ffff:0:ffff:ffff::", 1004},
-	        {"3333:4444:5555:6666::", "ffff:ffff:ffff:ffff::", 1005},
-	        {"3333:4444:5555:6666:aaaa:bbbb::", "ffff:ffff:ffff:ffff:ffff:ffff::", 1006},
-	        {"3333:4444:5555:6666:aaaa:bbbb:cccc:dddd", "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff", 1007},
-	};
-
-	for (auto [net, mask, value] : entries)
-	{
-		EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t(net), common::ipv6_address_t(mask), value));
-		t->print();
-	}
-
-	const std::vector<std::tuple<std::string, uint32_t>> cases{
-	        {"::1", 1001},
-	        {"1111:2222:c00::1", 1002},
-	        {"3333:4444:5555::1", 1003},
-	        {"3333:4444:5555:0:aaaa:bbbb:0:1", 1004},
-	        {"3333:4444:5555:1:aaaa:bbbb:0:1", 1004},
-	        {"3333:4444:5555:ffff:aaaa:bbbb:0:1", 1004},
-	        {"3333:4444:5555:6666::1", 1005},
-	        {"3333:4444:5555:6666:aaaa::1", 1005},
-	        {"3333:4444:5555:6666:0:bbbb:0:1", 1005},
-	        {"3333:4444:5555:6666:aaaa:bbbb:0:1", 1006},
-	        {"3333:4444:5555:6666:aaaa:bbbb:cccc:dddd", 1007},
-	};
-
-	for (auto [addr, value] : cases)
-	{
-		uint32_t valueId{0};
-		EXPECT_EQ(value != dataplane::lpmValueIdInvalid, t->lookup(common::ipv6_address_t(addr), &valueId));
-		EXPECT_EQ(value, valueId);
-	}
-
-	t->print();
-}
-
-TEST(LPM, LookupMerge)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	for (int i = 65535; i >= 1; i--)
-	{
-		std::array<uint8_t, 16> addr{0x11, 0x11, 0x22, 0x22, uint8_t(i / 256), uint8_t(i % 256), 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-		EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t(addr), common::ipv6_address_t("ffff:ffff:ffff::"), 1000));
-	}
-
-	EXPECT_EQ(2, t->getStats().extendedChunksCount);
-
-	std::array<uint8_t, 16> addr{0x11, 0x11, 0x22, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t(addr), common::ipv6_address_t("ffff:ffff:ffff::"), 1000));
-	EXPECT_EQ(1, t->getStats().extendedChunksCount);
-
-	t->print();
-}
-
-TEST(LPM, LookupCruelRealWorld)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<512>>();
-
-	std::ifstream stream("networks.txt");
-	std::string line;
-	int counter = 1000000; // Easier to match by eyes.
-	std::vector<std::tuple<std::string, std::string, uint32_t>> entries;
-	while (std::getline(stream, line))
-	{
-		auto pos = line.find('/');
-		auto addr = line.substr(0, pos);
-		auto mask = line.substr(pos + 1);
-		if (pos == std::string::npos)
-		{
-			mask = "128";
-		}
-
-		auto isNumber = !mask.empty() && std::all_of(mask.begin(), mask.end(), ::isdigit);
-		if (isNumber)
-		{
-			// Nevermind. The easiest way to convert ones set to proper IPv6 address.
-			mask = common::ipv6_address_t(t->createMask(std::stoi(mask, nullptr, 10))).toString();
-		}
-		entries.emplace_back(addr, mask, counter++);
-	}
-
-	for (auto [net, mask, value] : entries)
-	{
-		EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t(net), common::ipv6_address_t(mask), value))
-		        << "Failed to insert " << value;
-	}
-
-	t->print();
-}
-
-TEST(LPM, RemoveOne)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("2222:777:aabc:1234::"), 64, 4299));
-	EXPECT_EQ(3, t->getStats().extendedChunksCount);
-
-	EXPECT_EQ(eResult::success, t->remove(common::ipv6_address_t("2222:777:aabc:1234::"), 64));
-	EXPECT_EQ(0, t->getStats().extendedChunksCount);
-
-	t->print();
-}
-
-TEST(LPM, RemoveNotSame)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("::"), 0, 4299));
-	EXPECT_EQ(0, t->getStats().extendedChunksCount);
-
-	EXPECT_EQ(eResult::success, t->remove(common::ipv6_address_t("::1"), 128));
-	EXPECT_EQ(7, t->getStats().extendedChunksCount);
-
-	uint32_t valueId{0};
-	EXPECT_FALSE(t->lookup(common::ipv6_address_t("::1"), &valueId));
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("::2"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	t->print();
-}
-
-TEST(LPM, RemoveNet)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("1111:2222::"), 32, 100));
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("1111:2222:3333::"), 48, 101));
-	EXPECT_EQ(2, t->getStats().extendedChunksCount);
-
-	EXPECT_EQ(eResult::success, t->remove(common::ipv6_address_t("1111:2222::"), 32));
-	EXPECT_EQ(0, t->getStats().extendedChunksCount);
-
-	t->print();
-}
-
-TEST(LPM, RemoveOneWithMask)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("2222:777:aabc:1234::"), common::ipv6_address_t("ffff:ffff:ffff:ffff::"), 4299));
-	EXPECT_EQ(3, t->getStats().extendedChunksCount);
-
-	EXPECT_EQ(eResult::success, t->remove(common::ipv6_address_t("2222:777:aabc:1234::"), common::ipv6_address_t("ffff:ffff:ffff:ffff::")));
-	EXPECT_EQ(0, t->getStats().extendedChunksCount);
-
-	t->print();
-}
-
-TEST(LPM, RemoveNotSameWithMask)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("::"), common::ipv6_address_t("::"), 4299));
-	EXPECT_EQ(0, t->getStats().extendedChunksCount);
-
-	EXPECT_EQ(eResult::success, t->remove(common::ipv6_address_t("::1"), common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff")));
-	EXPECT_EQ(7, t->getStats().extendedChunksCount);
-
-	uint32_t valueId{0};
-	EXPECT_FALSE(t->lookup(common::ipv6_address_t("::1"), &valueId));
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("::2"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	t->print();
-}
-
-TEST(LPM, RemoveNetWithMask)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("1111:2222::"), common::ipv6_address_t("ffff:ffff::"), 100));
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("1111:2222:3333::"), common::ipv6_address_t("ffff:ffff:ffff::"), 101));
-	EXPECT_EQ(2, t->getStats().extendedChunksCount);
-
-	EXPECT_EQ(eResult::success, t->remove(common::ipv6_address_t("1111:2222::"), common::ipv6_address_t("ffff:ffff::")));
-	EXPECT_EQ(0, t->getStats().extendedChunksCount);
-
-	t->print();
-}
-
-TEST(LPM, RemoveGappedNetwork)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t("::"), common::ipv6_address_t("::"), 4299));
-	EXPECT_EQ(0, t->getStats().extendedChunksCount);
-
-	EXPECT_EQ(eResult::success, t->remove(common::ipv6_address_t("1111:2222:0:0:aaaa:bbbb::"), common::ipv6_address_t("ffff:ffff:0:0:ffff:ffff:0:0")));
-	EXPECT_EQ(5, t->getStats().extendedChunksCount);
-
-	uint32_t valueId{0};
-	EXPECT_FALSE(t->lookup(common::ipv6_address_t("1111:2222:3333:4444:aaaa:bbbb::1"), &valueId));
-	EXPECT_EQ(dataplane::lpmValueIdInvalid, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("1111:2222:3333:4444:aaaa:cccc::2"), &valueId));
-	EXPECT_EQ(4299, valueId);
-
-	t->print();
-}
-
-TEST(LPM, LookupSummaryWithClear)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	const std::vector<std::tuple<std::string, std::string, uint32_t>> entries{
-	        {"::", "::", 1001},
-	        {"1111:2222::", "ffff:ffff::", 1002},
-	        {"3333:4444:5555::", "ffff:ffff:ffff::", 1003},
-	        {"3333:4444:5555:0:aaaa:bbbb::", "ffff:ffff:ffff:0:ffff:ffff::", 1004},
-	        {"3333:4444:5555:6666::", "ffff:ffff:ffff:ffff::", 1005},
-	        {"3333:4444:5555:6666:aaaa:bbbb::", "ffff:ffff:ffff:ffff:ffff:ffff::", 1006},
-	};
-
-	for (auto [net, mask, value] : entries)
-	{
-		EXPECT_EQ(eResult::success, t->insert(common::ipv6_address_t(net), common::ipv6_address_t(mask), value));
-	}
-
-	EXPECT_EQ(eResult::success, t->remove(common::ipv6_address_t("::"), common::ipv6_address_t("::")));
-	EXPECT_EQ(0, t->getStats().extendedChunksCount);
-
-	t->print();
-}
-
-TEST(LPM, InsertCorruption)
-{
-	auto t = std::make_unique<lpm6_8x16bit_atomic<64>>();
-
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777::00af"),
-	                    common::ipv6_address_t("ffff:ffff::ffff:ffff:ffff:ffff"),
-	                    4299));
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777:1a::a1"),
-	                    common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
-	                    589));
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777:2a::a1"),
-	                    common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
-	                    105));
-
-	uint32_t valueId{0};
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:1a::a1"), &valueId));
-	EXPECT_EQ(589, valueId);
-
-	t->print();
-
-	t->clear();
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777::00af"),
-	                    common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
-	                    456));
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777:1a::00af"),
-	                    common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
-	                    890));
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777:2a::00af"),
-	                    common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
-	                    999));
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777::00af"),
-	                    common::ipv6_address_t("ffff:ffff::ffff:ffff:ffff:ffff"),
-	                    4299));
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777:1a::a1"),
-	                    common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
-	                    589));
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777:2a::a1"),
-	                    common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
-	                    105));
-
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777::af"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:1a::a1"), &valueId));
-	EXPECT_EQ(589, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:2a::a1"), &valueId));
-	EXPECT_EQ(105, valueId);
-
-	t->print();
-
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777:1a::a1"),
-	                    common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
-	                    1112));
-	EXPECT_EQ(eResult::success,
-	          t->insert(common::ipv6_address_t("2222:777:2a::a1"),
-	                    common::ipv6_address_t("ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff"),
-	                    1221));
-
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777::af"), &valueId));
-	EXPECT_EQ(4299, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:1a::a1"), &valueId));
-	EXPECT_EQ(1112, valueId);
-	EXPECT_TRUE(t->lookup(common::ipv6_address_t("2222:777:2a::a1"), &valueId));
-	EXPECT_EQ(1221, valueId);
-
-	t->print();
-}
-
-} // namespace
diff --git a/dataplane/unittest/sdp.cpp b/dataplane/unittest/sdp.cpp
index 312e024f..992cd7ff 100644
--- a/dataplane/unittest/sdp.cpp
+++ b/dataplane/unittest/sdp.cpp
@@ -9,8 +9,8 @@ class TestBus
 public:
 	static uint64_t GetSizeForCounters()
 	{
-		uint32_t count_errors = static_cast<uint32_t>(common::idp::errorType::size);
-		uint32_t count_requests = static_cast<uint32_t>(common::idp::requestType::size);
+		auto count_errors = static_cast<uint32_t>(common::idp::errorType::size);
+		auto count_requests = static_cast<uint32_t>(common::idp::requestType::size);
 		return (count_errors + 2 * count_requests) * sizeof(uint64_t);
 	}
 
@@ -39,11 +39,11 @@ class TestBus
 	void CompareWithClient(const common::sdp::DataPlaneInSharedMemory& sdp_data_client)
 	{
 		void* buffer = common::sdp::ShiftBuffer<void*>(sdp_data_client.dataplane_data, sdp_data_client.start_bus_section);
-		uint32_t count_errors = static_cast<uint32_t>(common::idp::errorType::size);
-		uint32_t count_requests = static_cast<uint32_t>(common::idp::requestType::size);
-		uint64_t* requests = common::sdp::ShiftBuffer<uint64_t*>(buffer, 0);
-		uint64_t* errors = common::sdp::ShiftBuffer<uint64_t*>(buffer, count_requests * sizeof(uint64_t));
-		uint64_t* durations = common::sdp::ShiftBuffer<uint64_t*>(buffer, (count_requests + count_errors) * sizeof(uint64_t));
+		auto count_errors = static_cast<uint32_t>(common::idp::errorType::size);
+		auto count_requests = static_cast<uint32_t>(common::idp::requestType::size);
+		auto* requests = common::sdp::ShiftBuffer<uint64_t*>(buffer, 0);
+		auto* errors = common::sdp::ShiftBuffer<uint64_t*>(buffer, count_requests * sizeof(uint64_t));
+		auto* durations = common::sdp::ShiftBuffer<uint64_t*>(buffer, (count_requests + count_errors) * sizeof(uint64_t));
 
 		for (uint32_t index = 0; index < static_cast<uint32_t>(common::idp::requestType::size); index++)
 		{
@@ -207,7 +207,7 @@ class TestWorker
 		ASSERT_EQ(common::sdp::SdpClient::GetCounterByName(sdp_data_client, "dropPackets", coreId)[coreId], stats->dropPackets);
 
 		// statsPorts
-		common::worker::stats::port* bufStatsPorts = common::sdp::ShiftBuffer<common::worker::stats::port*>(buffer, sdp_data_client.metadata_worker.start_stats_ports);
+		auto* bufStatsPorts = common::sdp::ShiftBuffer<common::worker::stats::port*>(buffer, sdp_data_client.metadata_worker.start_stats_ports);
 		for (uint32_t index = 0; index < CONFIG_YADECAP_PORTS_SIZE + 1; index++)
 		{
 			ASSERT_EQ(statsPorts[index].controlPlane_drops, bufStatsPorts[index].controlPlane_drops);
@@ -215,21 +215,21 @@ class TestWorker
 		}
 
 		// bursts
-		uint64_t* bufBursts = common::sdp::ShiftBuffer<uint64_t*>(buffer, sdp_data_client.metadata_worker.start_bursts);
+		auto* bufBursts = common::sdp::ShiftBuffer<uint64_t*>(buffer, sdp_data_client.metadata_worker.start_bursts);
 		for (uint32_t index = 0; index < CONFIG_YADECAP_MBUFS_BURST_SIZE + 1; index++)
 		{
 			ASSERT_EQ(bursts[index], bufBursts[index]);
 		}
 
 		// counters
-		uint64_t* bufCounters = common::sdp::ShiftBuffer<uint64_t*>(buffer, sdp_data_client.metadata_worker.start_counters);
+		auto* bufCounters = common::sdp::ShiftBuffer<uint64_t*>(buffer, sdp_data_client.metadata_worker.start_counters);
 		for (uint32_t index = 0; index < YANET_CONFIG_COUNTERS_SIZE; index++)
 		{
 			ASSERT_EQ(counters[index], bufCounters[index]);
 		}
 
 		// aclCounters
-		uint64_t* bufAclCounters = common::sdp::ShiftBuffer<uint64_t*>(buffer, sdp_data_client.metadata_worker.start_acl_counters);
+		auto* bufAclCounters = common::sdp::ShiftBuffer<uint64_t*>(buffer, sdp_data_client.metadata_worker.start_acl_counters);
 		for (uint32_t index = 0; index < YANET_CONFIG_ACL_COUNTERS_SIZE; index++)
 		{
 			ASSERT_EQ(aclCounters[index], bufAclCounters[index]);
@@ -302,7 +302,7 @@ class TestWorkerGc
 		ASSERT_EQ(common::sdp::SdpClient::GetCounterByName(sdp_data_client, "drop_samples", coreId)[coreId], stats->drop_samples);
 
 		// counters
-		uint64_t* bufCounters = common::sdp::ShiftBuffer<uint64_t*>(buffer, sdp_data_client.metadata_worker_gc.start_counters);
+		auto* bufCounters = common::sdp::ShiftBuffer<uint64_t*>(buffer, sdp_data_client.metadata_worker_gc.start_counters);
 		for (uint32_t index = 0; index < YANET_CONFIG_COUNTERS_SIZE; index++)
 		{
 			ASSERT_EQ(counters[index], bufCounters[index]);
diff --git a/dataplane/updater.h b/dataplane/updater.h
index 6f50d7b3..b3b0dc04 100644
--- a/dataplane/updater.h
+++ b/dataplane/updater.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <mutex>
 #include <nlohmann/json.hpp>
 #include <rte_malloc.h>
 
@@ -181,22 +180,22 @@ class updater_lpm
 		return eResult::success;
 	}
 
-	bool NeedToGrow() const
+	[[nodiscard]] bool NeedToGrow() const
 	{
 		return stats_.extended_chunks_size - stats_.extended_chunks_count < ObjectType::extended_chunks_size_min;
 	}
 
-	std::size_t GrowSize() const
+	[[nodiscard]] std::size_t GrowSize() const
 	{
 		return stats_.extended_chunks_size * 2;
 	}
 
-	std::size_t ShrinkSize() const
+	[[nodiscard]] std::size_t ShrinkSize() const
 	{
 		return stats_.extended_chunks_size / 2;
 	}
 
-	bool NeedToShrink() const
+	[[nodiscard]] bool NeedToShrink() const
 	{
 		return ShrinkSize() > std::max(ObjectType::extended_chunks_size_min, GrowSize());
 	}
@@ -216,8 +215,7 @@ class updater_lpm4_24bit_8bit_id32
 	                             const tSocketId socket_id) :
 	        name(name),
 	        memory_manager(memory_manager),
-	        socket_id(socket_id),
-	        pointer(nullptr)
+	        socket_id(socket_id)
 	{
 	}
 
@@ -291,7 +289,7 @@ class updater_lpm4_24bit_8bit_id32
 	object_type::stats_t stats;
 
 public:
-	object_type* pointer;
+	object_type* pointer{};
 };
 
 //
@@ -306,8 +304,7 @@ class updater_lpm6_16x8bit_id32
 	                          const tSocketId socket_id) :
 	        name(name),
 	        memory_manager(memory_manager),
-	        socket_id(socket_id),
-	        pointer(nullptr)
+	        socket_id(socket_id)
 	{
 	}
 
@@ -381,7 +378,7 @@ class updater_lpm6_16x8bit_id32
 	object_type::stats_t stats;
 
 public:
-	object_type* pointer;
+	object_type* pointer{};
 };
 
 //
diff --git a/dataplane/utils.h b/dataplane/utils.h
index d8e8afae..8b713712 100644
--- a/dataplane/utils.h
+++ b/dataplane/utils.h
@@ -3,10 +3,6 @@
 
 #include <rte_mbuf.h>
 
-#include "common/config.h"
-#include "common/define.h"
-#include "common/type.h"
-#include "dpdk.h"
 #include "metadata.h"
 
 namespace utils
@@ -62,4 +58,4 @@ class Sequential
 	}
 };
 
-} // namespace utils
\ No newline at end of file
+} // namespace utils
diff --git a/dataplane/worker.cpp b/dataplane/worker.cpp
index 861edc75..88f3f720 100644
--- a/dataplane/worker.cpp
+++ b/dataplane/worker.cpp
@@ -21,6 +21,8 @@
 #include "common/fallback.h"
 #include "common/nat46clat.h"
 
+#include "dataplane/sdpserver.h"
+
 #include "action_dispatcher.h"
 #include "checksum.h"
 #include "common.h"
@@ -2183,7 +2185,7 @@ inline void cWorker::route_handle4()
 				key.address.mapped_ipv4_address.address = nexthop.neighbor_address.mapped_ipv4_address.address;
 			}
 
-			dataplane::neighbor::value const* value;
+			dataplane::neighbor::value const* value = nullptr;
 			base.neighbor_hashtable->lookup(key, value);
 			if (value)
 			{
@@ -2307,7 +2309,7 @@ inline void cWorker::route_handle6()
 				memcpy(key.address.bytes, nexthop.neighbor_address.bytes, 16);
 			}
 
-			dataplane::neighbor::value const* value;
+			dataplane::neighbor::value const* value = nullptr;
 			base.neighbor_hashtable->lookup(key, value);
 			if (value)
 			{
@@ -2522,7 +2524,7 @@ inline void cWorker::route_tunnel_handle4()
 				key.address.mapped_ipv4_address.address = nexthop.neighbor_address.mapped_ipv4_address.address;
 			}
 
-			dataplane::neighbor::value const* value;
+			dataplane::neighbor::value const* value = nullptr;
 			base.neighbor_hashtable->lookup(key, value);
 			if (value)
 			{
@@ -2649,7 +2651,7 @@ inline void cWorker::route_tunnel_handle6()
 				memcpy(key.address.bytes, nexthop.neighbor_address.bytes, 16);
 			}
 
-			dataplane::neighbor::value const* value;
+			dataplane::neighbor::value const* value = nullptr;
 			base.neighbor_hashtable->lookup(key, value);
 			if (value)
 			{
@@ -2718,7 +2720,7 @@ inline void cWorker::route_tunnel_nexthop(rte_mbuf* mbuf,
 		return;
 	}
 
-	uint16_t payload_length;
+	uint16_t payload_length = 0;
 	bool is_ipv4 = metadata->network_headerType == rte_cpu_to_be_16(RTE_ETHER_TYPE_IPV4);
 	if (is_ipv4 && !nexthop.is_ipv6)
 	{
@@ -2755,8 +2757,8 @@ inline void cWorker::route_tunnel_nexthop(rte_mbuf* mbuf,
 	}
 	else
 	{
-		uint32_t vtc_flow;
-		uint16_t payload_len;
+		uint32_t vtc_flow = 0;
+		uint16_t payload_len = 0;
 		if (is_ipv4)
 		{
 			rte_ipv4_hdr* ipv4HeaderInner = rte_pktmbuf_mtod_offset(mbuf, rte_ipv4_hdr*, metadata->network_headerOffset);
@@ -2969,8 +2971,8 @@ inline void cWorker::nat64stateful_lan_handle()
 
 		const auto& nat64stateful = base.globalBase->nat64statefuls[metadata->flow.data.nat64stateful_id];
 
-		dataplane::globalBase::nat64stateful_lan_value* value_lookup;
-		dataplane::spinlock_nonrecursive_t* locker;
+		dataplane::globalBase::nat64stateful_lan_value* value_lookup = nullptr;
+		dataplane::spinlock_nonrecursive_t* locker = nullptr;
 		const uint32_t hash = nat64stateful_lan_state->lookup(key, value_lookup, locker);
 		if (value_lookup)
 		{
@@ -3018,9 +3020,9 @@ inline void cWorker::nat64stateful_lan_handle()
 			wan_key.port_source = key.port_destination;
 			wan_key.port_destination = key.port_source;
 
-			uint32_t wan_hash;
-			dataplane::globalBase::nat64stateful_wan_value* wan_value_lookup;
-			dataplane::spinlock_nonrecursive_t* wan_locker;
+			uint32_t wan_hash = 0;
+			dataplane::globalBase::nat64stateful_wan_value* wan_value_lookup = nullptr;
+			dataplane::spinlock_nonrecursive_t* wan_locker = nullptr;
 			for (unsigned int try_i = 0;
 			     try_i < YANET_CONFIG_NAT64STATEFUL_INSERT_TRIES;
 			     try_i++)
@@ -3074,11 +3076,8 @@ inline void cWorker::nat64stateful_lan_handle()
 				}
 
 				/// @todo: create cross-numa state over slowworker?
-				for (unsigned int numa_i = 0;
-				     numa_i < YANET_CONFIG_NUMA_SIZE;
-				     numa_i++)
+				for (auto globalbase_atomic : basePermanently.globalBaseAtomics)
 				{
-					auto* globalbase_atomic = basePermanently.globalBaseAtomics[numa_i];
 					if (globalbase_atomic == basePermanently.globalBaseAtomic)
 					{
 						continue;
@@ -3114,11 +3113,8 @@ inline void cWorker::nat64stateful_lan_handle()
 
 				/// @todo: create cross-numa state over slowworker?
 				value.timestamp_last_packet = basePermanently.globalBaseAtomic->currentTime - YANET_CONFIG_STATE_TIMEOUT_MAX;
-				for (unsigned int numa_i = 0;
-				     numa_i < YANET_CONFIG_NUMA_SIZE;
-				     numa_i++)
+				for (auto globalbase_atomic : basePermanently.globalBaseAtomics)
 				{
-					auto* globalbase_atomic = basePermanently.globalBaseAtomics[numa_i];
 					if (globalbase_atomic == basePermanently.globalBaseAtomic)
 					{
 						continue;
@@ -3266,8 +3262,8 @@ inline void cWorker::nat64stateful_wan_handle()
 
 		const auto& nat64stateful = base.globalBase->nat64statefuls[metadata->flow.data.nat64stateful_id];
 
-		dataplane::globalBase::nat64stateful_wan_value* value_lookup;
-		dataplane::spinlock_nonrecursive_t* locker;
+		dataplane::globalBase::nat64stateful_wan_value* value_lookup = nullptr;
+		dataplane::spinlock_nonrecursive_t* locker = nullptr;
 		nat64stateful_wan_state->lookup(key, value_lookup, locker);
 		if (!value_lookup)
 		{
@@ -4059,8 +4055,8 @@ inline void cWorker::balancer_handle()
 
 		/// @todo: BALANCER TCP SYN
 
-		dataplane::globalBase::balancer_state_value_t* value;
-		dataplane::spinlock_nonrecursive_t* locker;
+		dataplane::globalBase::balancer_state_value_t* value = nullptr;
+		dataplane::spinlock_nonrecursive_t* locker = nullptr;
 		const uint32_t hash = basePermanently.globalBaseAtomic->balancer_state->lookup(key, value, locker);
 		bool rescheduleReal = false;
 		if (value)
@@ -4328,7 +4324,7 @@ inline void cWorker::balancer_ipv6_source(rte_ipv6_hdr* header,
                                           const rte_ipv4_hdr* ipv4HeaderInner,
                                           const rte_ipv6_hdr* ipv6HeaderInner)
 {
-	uint32_t random_src;
+	uint32_t random_src = 0;
 	if (ipv4HeaderInner)
 	{
 		random_src = ipv4HeaderInner->src_addr;
@@ -4672,8 +4668,8 @@ inline void cWorker::balancer_icmp_forward_handle()
 		const balancer_service_id_t service_id = metadata->flow.data.atomic >> 8;
 		const auto& service = base.globalBase->balancer_services[service_id];
 
-		dataplane::globalBase::balancer_state_value_t* value;
-		dataplane::spinlock_nonrecursive_t* locker;
+		dataplane::globalBase::balancer_state_value_t* value = nullptr;
+		dataplane::spinlock_nonrecursive_t* locker = nullptr;
 		basePermanently.globalBaseAtomic->balancer_state->lookup(key, value, locker);
 
 		if (value)
@@ -4759,8 +4755,8 @@ inline cWorker::FlowFromState cWorker::acl_checkstate(rte_mbuf* mbuf)
 			key.dst_port = 0;
 		}
 
-		dataplane::globalBase::fw_state_value_t* value;
-		dataplane::spinlock_nonrecursive_t* locker;
+		dataplane::globalBase::fw_state_value_t* value = nullptr;
+		dataplane::spinlock_nonrecursive_t* locker = nullptr;
 		basePermanently.globalBaseAtomic->fw4_state->lookup(key, value, locker);
 
 		return acl_checkstate(mbuf, value, locker);
@@ -4795,8 +4791,8 @@ inline cWorker::FlowFromState cWorker::acl_checkstate(rte_mbuf* mbuf)
 			key.dst_port = 0;
 		}
 
-		dataplane::globalBase::fw_state_value_t* value;
-		dataplane::spinlock_nonrecursive_t* locker;
+		dataplane::globalBase::fw_state_value_t* value = nullptr;
+		dataplane::spinlock_nonrecursive_t* locker = nullptr;
 		basePermanently.globalBaseAtomic->fw6_state->lookup(key, value, locker);
 
 		return acl_checkstate(mbuf, value, locker);
@@ -4894,16 +4890,15 @@ inline void cWorker::acl_create_state(rte_mbuf* mbuf, tAclId aclId, const common
 		value.tcp.dst_flags = 0;
 
 		bool emit = false;
-		for (unsigned int idx = 0; idx < YANET_CONFIG_NUMA_SIZE; ++idx)
+		for (auto atomic : basePermanently.globalBaseAtomics)
 		{
-			dataplane::globalBase::atomic* atomic = basePermanently.globalBaseAtomics[idx];
 			if (atomic == nullptr)
 			{
 				break;
 			}
 
-			dataplane::globalBase::fw_state_value_t* lookup_value;
-			dataplane::spinlock_nonrecursive_t* locker;
+			dataplane::globalBase::fw_state_value_t* lookup_value = nullptr;
+			dataplane::spinlock_nonrecursive_t* locker = nullptr;
 			const uint32_t hash = atomic->fw4_state->lookup(key, lookup_value, locker);
 			if (lookup_value)
 			{
@@ -4992,16 +4987,15 @@ inline void cWorker::acl_create_state(rte_mbuf* mbuf, tAclId aclId, const common
 		value.tcp.dst_flags = 0;
 
 		bool emit = false;
-		for (unsigned int idx = 0; idx < YANET_CONFIG_NUMA_SIZE; ++idx)
+		for (auto atomic : basePermanently.globalBaseAtomics)
 		{
-			dataplane::globalBase::atomic* atomic = basePermanently.globalBaseAtomics[idx];
 			if (atomic == nullptr)
 			{
 				break;
 			}
 
-			dataplane::globalBase::fw_state_value_t* lookup_value;
-			dataplane::spinlock_nonrecursive_t* locker;
+			dataplane::globalBase::fw_state_value_t* lookup_value = nullptr;
+			dataplane::spinlock_nonrecursive_t* locker = nullptr;
 			const uint32_t hash = atomic->fw6_state->lookup(key, lookup_value, locker);
 			if (lookup_value)
 			{
@@ -5390,7 +5384,7 @@ void cWorker::acl_log(rte_mbuf* mbuf, const common::globalBase::tFlow& flow, tAc
 	const auto& base = bases[localBaseId & 1];
 	dataplane::metadata* metadata = YADECAP_METADATA(mbuf);
 
-	samples::sample_t* sample;
+	samples::sample_t* sample = nullptr;
 	if (rte_mempool_get(dataPlane->mempool_log, (void**)&sample) != 0)
 	{
 		stats->logs_drops++;
@@ -5488,8 +5482,8 @@ inline cWorker::FlowFromState cWorker::acl_egress_checkstate(rte_mbuf* mbuf)
 			key.dst_port = 0;
 		}
 
-		dataplane::globalBase::fw_state_value_t* value;
-		dataplane::spinlock_nonrecursive_t* locker;
+		dataplane::globalBase::fw_state_value_t* value = nullptr;
+		dataplane::spinlock_nonrecursive_t* locker = nullptr;
 		basePermanently.globalBaseAtomic->fw4_state->lookup(key, value, locker);
 
 		return acl_egress_checkstate(mbuf, value, locker);
@@ -5524,8 +5518,8 @@ inline cWorker::FlowFromState cWorker::acl_egress_checkstate(rte_mbuf* mbuf)
 			key.dst_port = 0;
 		}
 
-		dataplane::globalBase::fw_state_value_t* value;
-		dataplane::spinlock_nonrecursive_t* locker;
+		dataplane::globalBase::fw_state_value_t* value = nullptr;
+		dataplane::spinlock_nonrecursive_t* locker = nullptr;
 		basePermanently.globalBaseAtomic->fw6_state->lookup(key, value, locker);
 
 		return acl_egress_checkstate(mbuf, value, locker);
diff --git a/dataplane/worker.h b/dataplane/worker.h
index bc49d05c..57e97976 100644
--- a/dataplane/worker.h
+++ b/dataplane/worker.h
@@ -9,6 +9,7 @@
 #include <rte_ring.h>
 
 #include "common/result.h"
+#include "common/sdpcommon.h"
 #include "common/tsc_deltas.h"
 #include "common/type.h"
 
@@ -16,7 +17,6 @@
 #include "common.h"
 #include "globalbase.h"
 #include "samples.h"
-#include "sdpserver.h"
 #include "sharedmemory.h"
 
 namespace dataplane
@@ -32,10 +32,7 @@ template<unsigned int TSize = CONFIG_YADECAP_MBUFS_BURST_SIZE>
 class tStack
 {
 public:
-	tStack() :
-	        mbufsCount(0)
-	{
-	}
+	tStack() = default;
 
 	inline void insert(rte_mbuf** mbufs, unsigned int mbufsCount)
 	{
@@ -55,7 +52,7 @@ class tStack
 	}
 
 public:
-	unsigned int mbufsCount;
+	unsigned int mbufsCount{};
 	rte_mbuf* mbufs[TSize];
 };
 
@@ -75,7 +72,7 @@ class cWorker
 	static void FillMetadataWorkerCounters(common::sdp::MetadataWorker& metadata);
 	void SetBufferForCounters(void* buffer, const common::sdp::MetadataWorker& metadata);
 
-	const dataplane::base::generation& current_base() const { return bases[localBaseId & 1]; }
+	[[nodiscard]] const dataplane::base::generation& current_base() const { return bases[localBaseId & 1]; }
 
 protected:
 	eResult sanityCheck();
@@ -238,7 +235,7 @@ class cWorker
 	YANET_NEVER_INLINE void slowWorkerTranslation(rte_mbuf* mbuf, const dataplane::globalBase::tNat64stateless& nat64stateless, const dataplane::globalBase::nat64stateless_translation_t& translation, bool direction); /** true: ingress, false: egress */
 	const dataplane::base::generation& CurrentBase() { return bases[localBaseId & 1]; }
 	void IncrementCounter(common::globalBase::static_counter_type type) { counters[(uint32_t)type]++; }
-	uint32_t CurrentTime() const { return basePermanently.globalBaseAtomic->currentTime; }
+	[[nodiscard]] uint32_t CurrentTime() const { return basePermanently.globalBaseAtomic->currentTime; }
 
 	friend class cDataPlane;
 	friend class cReport;
diff --git a/dataplane/worker_gc.cpp b/dataplane/worker_gc.cpp
index 759c8703..2a645aa4 100644
--- a/dataplane/worker_gc.cpp
+++ b/dataplane/worker_gc.cpp
@@ -1,14 +1,11 @@
-#include <thread>
-
 #include <rte_errno.h>
 #include <rte_ethdev.h>
 
 #include "common/counters.h"
 #include "common/fallback.h"
-
-#include "dataplane.h"
-#include "worker.h"
-#include "worker_gc.h"
+#include "dataplane/globalbase.h"
+#include "dataplane/sdpserver.h"
+#include "dataplane/worker_gc.h"
 
 worker_gc_t::worker_gc_t(const ConfigValues& cfg, const PortToSocketArray& pts, SamplersVector&& samplers) :
         mempool(nullptr),
@@ -246,11 +243,8 @@ void worker_gc_t::handle_nat64stateful_gc()
 		const auto& nat64stateful = base.globalBase->nat64statefuls[wan_key.nat64stateful_id];
 
 		/// check other wan tables
-		for (unsigned int numa_i = 0;
-		     numa_i < YANET_CONFIG_NUMA_SIZE;
-		     numa_i++)
+		for (auto globalbase_atomic : base_permanently.globalBaseAtomics)
 		{
-			auto* globalbase_atomic = base_permanently.globalBaseAtomics[numa_i];
 			if (globalbase_atomic == base_permanently.globalBaseAtomic)
 			{
 				continue;
@@ -260,8 +254,8 @@ void worker_gc_t::handle_nat64stateful_gc()
 				break;
 			}
 
-			dataplane::globalBase::nat64stateful_wan_value* wan_value_lookup;
-			dataplane::spinlock_nonrecursive_t* wan_locker;
+			dataplane::globalBase::nat64stateful_wan_value* wan_value_lookup = nullptr;
+			dataplane::spinlock_nonrecursive_t* wan_locker = nullptr;
 			globalbase_atomic->nat64stateful_wan_state->lookup(wan_key, wan_value_lookup, wan_locker);
 			if (wan_value_lookup)
 			{
@@ -282,18 +276,15 @@ void worker_gc_t::handle_nat64stateful_gc()
 		lan_key.port_destination = wan_key.port_source;
 
 		/// check lan tables
-		for (unsigned int numa_i = 0;
-		     numa_i < YANET_CONFIG_NUMA_SIZE;
-		     numa_i++)
+		for (auto globalbase_atomic : base_permanently.globalBaseAtomics)
 		{
-			auto* globalbase_atomic = base_permanently.globalBaseAtomics[numa_i];
 			if (globalbase_atomic == nullptr)
 			{
 				break;
 			}
 
-			dataplane::globalBase::nat64stateful_lan_value* lan_value_lookup;
-			dataplane::spinlock_nonrecursive_t* lan_locker;
+			dataplane::globalBase::nat64stateful_lan_value* lan_value_lookup = nullptr;
+			dataplane::spinlock_nonrecursive_t* lan_locker = nullptr;
 			globalbase_atomic->nat64stateful_lan_state->lookup(lan_key, lan_value_lookup, lan_locker);
 			if (lan_value_lookup)
 			{
@@ -431,11 +422,8 @@ void worker_gc_t::handle_balancer_gc()
 				auto value = *iter.value();
 				iter.unlock();
 
-				for (unsigned int numa_i = 0;
-				     numa_i < YANET_CONFIG_NUMA_SIZE;
-				     numa_i++)
+				for (auto globalbase_atomic_other : base_permanently.globalBaseAtomics)
 				{
-					dataplane::globalBase::atomic* globalbase_atomic_other = base_permanently.globalBaseAtomics[numa_i];
 					if (globalbase_atomic_other == nullptr)
 					{
 						break;
@@ -449,9 +437,9 @@ void worker_gc_t::handle_balancer_gc()
 					bool saved = true;
 					bool updated = false;
 
-					dataplane::globalBase::balancer_state_value_t* ht_value;
-					dataplane::spinlock_nonrecursive_t* locker;
-					uint32_t old_real_id;
+					dataplane::globalBase::balancer_state_value_t* ht_value = nullptr;
+					dataplane::spinlock_nonrecursive_t* locker = nullptr;
+					uint32_t old_real_id = 0;
 
 					uint32_t hash = globalbase_atomic_other->balancer_state->lookup(*iter.key(), ht_value, locker);
 					if (ht_value)
@@ -954,7 +942,7 @@ void worker_gc_t::handle_callbacks()
 void worker_gc_t::handle_free_mbuf()
 {
 	rte_mbuf* mbufs[CONFIG_YADECAP_MBUFS_BURST_SIZE];
-	unsigned int mbufs_count;
+	unsigned int mbufs_count = 0;
 
 	for (auto& ring : toFree_)
 	{
@@ -972,7 +960,7 @@ inline bool worker_gc_t::is_timeout(const uint32_t timestamp,
 inline void worker_gc_t::correct_timestamp(uint16_t& timestamp,
                                            const uint16_t last_seen_max)
 {
-	uint16_t last_seen = (uint16_t)(current_time - timestamp);
+	auto last_seen = (uint16_t)(current_time - timestamp);
 	if (last_seen > last_seen_max)
 	{
 		timestamp = (uint16_t)(current_time - last_seen_max);
@@ -988,11 +976,8 @@ void worker_gc_t::nat64stateful_remove_state(const dataplane::globalBase::nat64s
                                              const dataplane::globalBase::nat64stateful_wan_key& wan_key)
 {
 	/// remove on other numas
-	for (unsigned int numa_i = 0;
-	     numa_i < YANET_CONFIG_NUMA_SIZE;
-	     numa_i++)
+	for (auto globalbase_atomic : base_permanently.globalBaseAtomics)
 	{
-		auto* globalbase_atomic = base_permanently.globalBaseAtomics[numa_i];
 		if (globalbase_atomic == base_permanently.globalBaseAtomic)
 		{
 			continue;
@@ -1110,11 +1095,8 @@ void worker_gc_t::nat64stateful_state(const common::idp::nat64stateful_state::re
 			uint16_t wan_last_seen = calc_last_seen(wan_value.timestamp_last_packet);
 
 			/// check other wan tables
-			for (unsigned int numa_i = 0;
-			     numa_i < YANET_CONFIG_NUMA_SIZE;
-			     numa_i++)
+			for (auto globalbase_atomic : base_permanently.globalBaseAtomics)
 			{
-				auto* globalbase_atomic = base_permanently.globalBaseAtomics[numa_i];
 				if (globalbase_atomic == base_permanently.globalBaseAtomic)
 				{
 					continue;
@@ -1124,8 +1106,8 @@ void worker_gc_t::nat64stateful_state(const common::idp::nat64stateful_state::re
 					break;
 				}
 
-				dataplane::globalBase::nat64stateful_wan_value* wan_value_lookup;
-				dataplane::spinlock_nonrecursive_t* wan_locker;
+				dataplane::globalBase::nat64stateful_wan_value* wan_value_lookup = nullptr;
+				dataplane::spinlock_nonrecursive_t* wan_locker = nullptr;
 				globalbase_atomic->nat64stateful_wan_state->lookup(wan_key, wan_value_lookup, wan_locker);
 				if (wan_value_lookup)
 				{
@@ -1145,18 +1127,15 @@ void worker_gc_t::nat64stateful_state(const common::idp::nat64stateful_state::re
 			lan_key.port_destination = wan_key.port_source;
 
 			/// check lan tables
-			for (unsigned int numa_i = 0;
-			     numa_i < YANET_CONFIG_NUMA_SIZE;
-			     numa_i++)
+			for (auto globalbase_atomic : base_permanently.globalBaseAtomics)
 			{
-				auto* globalbase_atomic = base_permanently.globalBaseAtomics[numa_i];
 				if (globalbase_atomic == nullptr)
 				{
 					break;
 				}
 
-				dataplane::globalBase::nat64stateful_lan_value* lan_value_lookup;
-				dataplane::spinlock_nonrecursive_t* lan_locker;
+				dataplane::globalBase::nat64stateful_lan_value* lan_value_lookup = nullptr;
+				dataplane::spinlock_nonrecursive_t* lan_locker = nullptr;
 				globalbase_atomic->nat64stateful_lan_state->lookup(lan_key, lan_value_lookup, lan_locker);
 				if (lan_value_lookup)
 				{
diff --git a/dataplane/worker_gc.h b/dataplane/worker_gc.h
index a74c56c9..074fb6df 100644
--- a/dataplane/worker_gc.h
+++ b/dataplane/worker_gc.h
@@ -5,14 +5,16 @@
 
 #include "base.h"
 #include "common.h"
+#include "common/sdpcommon.h"
+#include "config_values.h"
 #include "hashtable.h"
+#include "samples.h"
 #include "utils.h"
 
 #include "common/generation.h"
 #include "common/idp.h"
 #include "common/static_vector.h"
 #include "hashtable.h"
-#include "sdpserver.h"
 
 class worker_gc_t
 {
diff --git a/ext/xxhash32.h b/ext/xxhash32.h
index e801f503..857ad54a 100644
--- a/ext/xxhash32.h
+++ b/ext/xxhash32.h
@@ -163,13 +163,13 @@ class XXHash32
   uint64_t      totalLength;
 
   /// rotate bits, should compile to a single CPU instruction (ROL)
-  static inline uint32_t rotateLeft(uint32_t x, unsigned char bits)
+  static uint32_t rotateLeft(uint32_t x, unsigned char bits)
   {
     return (x << bits) | (x >> (32 - bits));
   }
 
   /// process a block of 4x4 bytes, this is the main part of the XXHash32 algorithm
-  static inline void process(const void* data, uint32_t& state0, uint32_t& state1, uint32_t& state2, uint32_t& state3)
+  static void process(const void* data, uint32_t& state0, uint32_t& state1, uint32_t& state2, uint32_t& state3)
   {
     const uint32_t* block = (const uint32_t*) data;
     state0 = rotateLeft(state0 + block[0] * Prime2, 13) * Prime1;
diff --git a/libfwparser/fw_config.cpp b/libfwparser/fw_config.cpp
index 0af9df32..c2459d40 100644
--- a/libfwparser/fw_config.cpp
+++ b/libfwparser/fw_config.cpp
@@ -16,17 +16,13 @@ using namespace ipfw;
 			std::cerr << "DEBUG: " << __func__ << ": " << msg << std::endl; \
 	} while (0)
 
-fw_config_t::fw_config_t(int step)
+fw_config_t::fw_config_t(int step) :
+        m_curr_entity(entity_type::NONE), m_debug(0), m_ruleid_last(0), m_ruleno_last(0)
 {
 	// use limits like in FreeBSD kernel
 	const auto value = std::clamp(step, 1, 1000);
 
-	m_debug = 0;
-	m_ruleid_last = 0;
-	m_ruleno_last = 0;
 	m_ruleno_step = value;
-
-	m_curr_entity = entity_type::NONE;
 	m_curr_rule = std::make_shared<rule_t>();
 	m_prev_rule = nullptr;
 
@@ -273,7 +269,7 @@ void fw_config_t::set_fqdn(const std::string& s)
 
 		location = {(unsigned int)l.begin.line, m_fileno.top()};
 		addresses.clear();
-		(void)used;
+		YANET_GCC_BUG_UNUSED(used);
 	}
 	else
 	{
@@ -651,7 +647,7 @@ void fw_config_t::add_rule_table(const std::string& name)
 
 	for (const auto& [prefix, label] : std::get<tables::prefix_skipto_t>(table))
 	{
-		(void)label;
+		YANET_GCC_BUG_UNUSED(label);
 		add_rule_addr(prefix);
 	}
 }
@@ -1201,7 +1197,7 @@ bool fw_config_t::validate()
 	}
 	for (auto& [ruleno, rules] : m_rules)
 	{
-		(void)ruleno;
+		YANET_GCC_BUG_UNUSED(ruleno);
 		for (auto rulep : rules)
 		{
 			if (!validate_rule(rulep))
diff --git a/libfwparser/fw_config.h b/libfwparser/fw_config.h
index 6f6b002f..66ae9372 100644
--- a/libfwparser/fw_config.h
+++ b/libfwparser/fw_config.h
@@ -431,11 +431,11 @@ class fw_config_t
 
 	void set_fqdn(const std::string&);
 	void fill_fqdn(const common::ip_address_t&);
-	const auto& resolve_fqdn(const std::string& s) const
+	[[nodiscard]] const auto& resolve_fqdn(const std::string& s) const
 	{
 		return std::get<1>(m_dns_cache.at(s));
 	}
-	const auto& resolve_macro(const std::string& s) const
+	[[nodiscard]] const auto& resolve_macro(const std::string& s) const
 	{
 		return std::get<1>(m_macros.at(s));
 	}
@@ -518,7 +518,7 @@ class fw_config_t
 	void add_implicit_check_state_rule();
 
 	std::string format_location(const location_history_t& loc);
-	const auto& labels() const
+	[[nodiscard]] const auto& labels() const
 	{
 		return m_labels;
 	}
diff --git a/libfwparser/fw_lexer.cpp b/libfwparser/fw_lexer.cpp
index cad85fed..e5773853 100644
--- a/libfwparser/fw_lexer.cpp
+++ b/libfwparser/fw_lexer.cpp
@@ -110,7 +110,7 @@ fw_lexer_t::make_IP6PRJID(const std::string& s, fw_parser_t::location_type& l)
 	common::ipv6_address_t addr;
 	std::string tmp = s;
 	uint32_t prjid = 0;
-	int prefixlen, prjid_prefixlen = 32;
+	int prefixlen = 0, prjid_prefixlen = 32;
 
 	// handle addresses with holes in masks 1407@2a02:6b8:c00::/40
 	auto pos = tmp.find("@");
diff --git a/librib/libyabird.cpp b/librib/libyabird.cpp
index abc464f0..04767c88 100644
--- a/librib/libyabird.cpp
+++ b/librib/libyabird.cpp
@@ -7,7 +7,6 @@
 
 #include "common/define.h"
 #include "common/icontrolplane.h"
-#include "common/result.h"
 #include "common/type.h"
 
 #include "libyabird.h"
@@ -180,12 +179,12 @@ void libyabird_t::update(yanet_data_t* data)
 		std::set<common::community_t> attribute_communities;
 		std::set<common::large_community_t> attribute_large_communities;
 		std::vector<uint32_t> labels;
-		node* n;
-		yanet_prefix_t* p;
-		yanet_u32_t* uptr;
+		node* n = nullptr;
+		yanet_prefix_t* p = nullptr;
+		yanet_u32_t* uptr = nullptr;
 		uint32_t attribute_local_preference = 0;
 		uint32_t attribute_med = 0;
-		uint32_t i;
+		uint32_t i = 0;
 
 		if (data->flags & YANET_ORIGIN)
 			attribute_origin = std::string(data->origin);
@@ -259,7 +258,7 @@ void libyabird_t::update(yanet_data_t* data)
 				WALK_LIST(n, data->prefixes)
 				{
 					common::ip_prefix_t prefix;
-					size_t pos;
+					size_t pos = 0;
 
 					p = reinterpret_cast<yanet_prefix_t*>(n);
 
@@ -306,7 +305,7 @@ void libyabird_t::update(yanet_data_t* data)
 			WALK_LIST(n, data->withdraw)
 			{
 				common::ip_prefix_t prefix;
-				size_t pos;
+				size_t pos = 0;
 
 				p = reinterpret_cast<yanet_prefix_t*>(n);
 
@@ -375,7 +374,7 @@ yanet_open(void)
 	{
 		std::cerr << __func__ << " failed" << std::endl;
 	}
-	return (NULL);
+	return (nullptr);
 }
 
 extern "C" void
diff --git a/librib/libyabird.h b/librib/libyabird.h
index d7214a73..464794e0 100644
--- a/librib/libyabird.h
+++ b/librib/libyabird.h
@@ -1,6 +1,7 @@
 #ifndef _LIBYABIRD_H_
 #define _LIBYABIRD_H_
 
+#include <cstdint>
 #ifdef __cplusplus
 /*
  * Simple LIST implementation used in bird2.
@@ -96,7 +97,7 @@ extern "C"
 };
 #else /* __cplusplus */
 
-//#define	YANET_DEBUG
+// #define	YANET_DEBUG
 
 #ifdef YANET_DEBUG
 #include <cstdio>
diff --git a/logger/main.cpp b/logger/main.cpp
index 1492ee98..aef83344 100644
--- a/logger/main.cpp
+++ b/logger/main.cpp
@@ -1,5 +1,5 @@
+#include <csignal>
 #include <fstream>
-#include <signal.h>
 #include <systemd/sd-daemon.h>
 #include <thread>
 
@@ -9,9 +9,9 @@
 #include <rte_ring.h>
 #include <rte_version.h>
 
+#include "common/define.h"
 #include "common/icontrolplane.h"
 #include "common/idataplane.h"
-#include "common/result.h"
 #include "common/type.h"
 
 #include "dataplane/samples.h"
@@ -42,13 +42,13 @@ int initLogger()
 	auto response = dataplane.getConfig();
 	auto& workers = std::get<1>(response);
 
-	for (auto it : workers)
+	for (auto& [core, workers_vector] : workers)
 	{
-		auto coreId = it.first;
-		auto ring = rte_ring_lookup(("r_log_" + std::to_string(coreId)).c_str());
-		if (ring != NULL)
+		YANET_GCC_BUG_UNUSED(workers_vector);
+		auto ring = rte_ring_lookup(("r_log_" + std::to_string(core)).c_str());
+		if (ring != nullptr)
 		{
-			YANET_LOG_DEBUG("found log ring on #%u core\n", coreId);
+			YANET_LOG_DEBUG("found log ring on #%u core\n", core);
 
 			rings.push_back(ring);
 		}
@@ -90,8 +90,8 @@ int runLogger()
 
 	interface::controlPlane controlplane;
 
-	uint32_t size = 1024;
-	samples::sample_t* samples[size];
+	constexpr uint32_t size = 1024;
+	std::array<samples::sample_t*, size> samples;
 
 	std::map<uint32_t, common::icp::getAclConfig::response> configs;
 
@@ -151,7 +151,7 @@ int runLogger()
 				if (aclConfig != nullptr)
 				{
 					auto& [serial, ifaces, rules] = *aclConfig;
-					(void)serial;
+					YANET_GCC_BUG_UNUSED(serial);
 
 					auto it = ifaces.find(sample->acl_id);
 					if (it != ifaces.end())
@@ -169,14 +169,14 @@ int runLogger()
 				}
 
 				std::cout << "{"
-				          << "\"action\":\"" << common::globalBase::eFlowType_toString(sample->action) << "\","
+				          << R"("action":")" << common::globalBase::eFlowType_toString(sample->action) << "\","
 				          << "\"rule_ids\":[" << rule_ids << "],"
 				          << "\"direction\":" << (direction ? "\"in\"" : "\"out\"") << ","
-				          << "\"iface\":\"" << iface << "\","
+				          << R"("iface":")" << iface << "\","
 				          << "\"proto\":" << (int)sample->proto << ","
-				          << "\"src_addr\":\"" << src_addr.toString() << "\","
+				          << R"("src_addr":")" << src_addr.toString() << "\","
 				          << "\"src_port\":" << sample->src_port << ","
-				          << "\"dst_addr\":\"" << dst_addr.toString() << "\","
+				          << R"("dst_addr":")" << dst_addr.toString() << "\","
 				          << "\"dst_port\":" << sample->dst_port << "}\n";
 
 				rte_mempool_put(mempool, sample);
@@ -232,82 +232,84 @@ int loadConfig(const std::string& path)
 	return 0;
 }
 
-int main(int argc,
-         char** argv)
+int main(int argc, char** argv)
 {
 	int config = argc;
 	for (int i = 1; i < argc; i++)
 	{
-		if (strcmp(argv[i], "-d") == 0)
+		std::string_view arg{argv[i]};
+		if (arg == "-d")
 		{
 			common::log::logPriority = common::log::TLOG_DEBUG;
 		}
-		else if (strcmp(argv[i], "-c") == 0)
+		else if (arg == "-c")
 		{
 			config = i + 1;
 		}
 	}
+
 	if (config >= argc)
 	{
 		std::cout << "usage: " << argv[0] << " [-d] -c <logger.conf>" << std::endl;
 		return 1;
 	}
+
 	int ret = loadConfig(argv[config]);
 	if (ret != 0)
 	{
 		return ret;
 	}
 
-	std::vector<const char*> args;
+	std::vector<std::string> args;
 	args.push_back(argv[0]);
-	args.push_back("--proc-type=secondary");
+	args.emplace_back("--proc-type=secondary");
 
 	std::string filePrefix = "--file-prefix=";
+	if (const char* pointer = std::getenv("YANET_FILEPREFIX"))
 	{
-		char* pointer = getenv("YANET_FILEPREFIX");
-		if (pointer)
-		{
-			filePrefix += pointer;
-		}
-		else
-		{
-			char* pointer = getenv("YANET_PREFIX");
-			if (pointer)
-			{
-				filePrefix += pointer;
-			}
-		}
+		filePrefix += pointer;
 	}
+	else if (const char* pointer = std::getenv("YANET_PREFIX"))
+	{
+		filePrefix += pointer;
+	}
+
 	if (filePrefix.size() > std::string("--file-prefix=").size())
 	{
-		args.push_back(filePrefix.data());
+		args.push_back(filePrefix);
 	}
 
 #if (RTE_VER_YEAR < 20) || (RTE_VER_YEAR == 20 && RTE_VER_MONT < 11)
-	const char masterLcore[] = "--master-lcore";
+	const std::string masterLcore = "--master-lcore";
 #else
-	const char masterLcore[] = "--main-lcore";
+	const std::string masterLcore = "--main-lcore";
 #endif
 
 	std::string masterLcoreId = std::to_string(loggerCoreId);
-
 	args.push_back(masterLcore);
-	args.push_back(masterLcoreId.data());
+	args.push_back(masterLcoreId);
 
 	YANET_LOG_DEBUG("eal args:\n");
-	for (uint32_t i = 0; i < args.size(); ++i)
+	for (const auto& arg : args)
+	{
+		YANET_LOG_DEBUG("%s\n", arg.c_str());
+	}
+
+	// Use std::vector<char*> and copy the data into it for passing to rte_eal_init
+	std::vector<char*> c_args;
+	for (auto& arg : args)
 	{
-		YANET_LOG_DEBUG("%s\n", args[i]);
+		c_args.push_back(const_cast<char*>(arg.c_str()));
 	}
 
-	ret = rte_eal_init(args.size(), (char**)args.data());
+	ret = rte_eal_init(static_cast<int>(c_args.size()), c_args.data());
 	if (ret < 0)
 	{
 		YANET_LOG_ERROR("rte_eal_init() = %d\n", ret);
 		return 2;
 	}
 
-	if (signal(SIGPIPE, handleSignal) == SIG_ERR)
+	if (std::signal(SIGPIPE, handleSignal) == SIG_ERR)
 	{
 		return 3;
 	}
diff --git a/meson.build b/meson.build
index 29fd6af9..08c20a68 100644
--- a/meson.build
+++ b/meson.build
@@ -64,9 +64,11 @@ if target_option.contains('buildenv')
     subdir('parser')
     subdir_done()
 elif target_option.contains('unittest')
+    subdir('libprotobuf')
     subdir('libfwparser')
     subdir('dataplane/unittest')
     subdir('controlplane/unittest')
+    subdir('cli/unittest')
     subdir('common/unittest')
     subdir_done()
 endif
diff --git a/parser/fw_dump.cpp b/parser/fw_dump.cpp
index 1fcbf41d..c1c75c70 100644
--- a/parser/fw_dump.cpp
+++ b/parser/fw_dump.cpp
@@ -11,7 +11,7 @@ void fw_dump_t::dump_dnscache()
 		const auto& [lh, addresses, actual] = values;
 		bool comma = false;
 
-		(void)lh;
+		YANET_GCC_BUG_UNUSED(lh);
 		std::cerr << fqdn << " ";
 		for (const auto& addr : addresses)
 		{
@@ -33,7 +33,7 @@ void fw_dump_t::dump_tables()
 	{
 		const auto& [lh, table] = values;
 
-		(void)lh;
+		YANET_GCC_BUG_UNUSED(lh);
 		std::cerr << "table " << name << " create type " << types[table.index()] << std::endl;
 		if (std::holds_alternative<tables::prefix_skipto_t>(table))
 		{
@@ -64,7 +64,7 @@ void fw_dump_t::dump_macros()
 		const auto& [lh, prefixes, used] = values;
 		bool comma = false;
 
-		(void)lh;
+		YANET_GCC_BUG_UNUSED(lh);
 		if (!used)
 		{
 			// comment unused macros
@@ -250,7 +250,7 @@ void fw_dump_t::dump_rule(rule_ptr_t rulep)
 		std::cerr << "# via: ";
 		for (const auto& [name, how] : rulep->ifaces)
 		{
-			(void)how;
+			YANET_GCC_BUG_UNUSED(how);
 			if (many)
 				std::cerr << " or ";
 			std::cerr << name;
@@ -264,7 +264,7 @@ void fw_dump_t::dump_rule(rule_ptr_t rulep)
 		std::cerr << "# via table: ";
 		for (const auto& [how, tables] : rulep->iface_tables)
 		{
-			(void)how;
+			YANET_GCC_BUG_UNUSED(how);
 			for (const auto& name : tables)
 			{
 				if (comma)
@@ -283,7 +283,7 @@ void fw_dump_t::dump_rules()
 	std::cerr << "#----------------------------------------" << std::endl;
 	for (auto& [ruleno, rules] : m_conf->m_rules)
 	{
-		(void)ruleno;
+		YANET_GCC_BUG_UNUSED(ruleno);
 		for (auto rulep : rules)
 		{
 			dump_rule(rulep);
diff --git a/parser/fw_dump.h b/parser/fw_dump.h
index 7551b19e..1b74f5aa 100644
--- a/parser/fw_dump.h
+++ b/parser/fw_dump.h
@@ -1,6 +1,7 @@
 #pragma once
 
-#include "fw_parser.h"
+#include "libfwparser/fw_config.h"
+#include "libfwparser/fw_parser.h"
 #include <memory>
 
 namespace ipfw
diff --git a/parser/main.cpp b/parser/main.cpp
index 279558ff..d06dc146 100644
--- a/parser/main.cpp
+++ b/parser/main.cpp
@@ -36,9 +36,9 @@ int main(int argc, char* argv[])
 {
 	std::shared_ptr<ipfw::fw_config_t> config;
 	std::string dname, fname, mname;
-	bool cmd_mode, quiet_mode, test_mode, dump, success, sanity;
+	bool cmd_mode = false, quiet_mode = false, test_mode = false, dump = false, success = false, sanity = false;
 	int verbose_level = 0;
-	char ch;
+	char ch = 0;
 
 	cmd_mode = quiet_mode = test_mode = dump = sanity = false;
 	while (!cmd_mode && (ch = getopt(argc, argv, "d:f:c:m:Dqsvnh")) != -1)
@@ -98,12 +98,12 @@ int main(int argc, char* argv[])
 	config->set_debug(verbose_level);
 
 	/*
-     * For -c option we concatenate all remaining arguments into
-     * single spaces delimited string and pass it to the parser.
-     *
-     * NOTE: the order of scheduled files is matter. DNS cache
-     * should be scheduled last, then it will be processed first.
-     */
+	 * For -c option we concatenate all remaining arguments into
+	 * single spaces delimited string and pass it to the parser.
+	 *
+	 * NOTE: the order of scheduled files is matter. DNS cache
+	 * should be scheduled last, then it will be processed first.
+	 */
 	if (cmd_mode)
 	{
 		/* Rule from command line arguments */
diff --git a/unwind/unwind.cpp b/unwind/unwind.cpp
index 1856b41f..8bac5586 100644
--- a/unwind/unwind.cpp
+++ b/unwind/unwind.cpp
@@ -1,7 +1,6 @@
 #include <cerrno>
 #include <cstdlib>
 #include <cstring>
-#include <fstream>
 #include <iostream>
 #include <memory>
 #include <string>
@@ -90,7 +89,7 @@ int main(int argc, char* argv[])
 	common::acl::iface_map_t ifmap;
 	std::set<std::string> oif, iif;
 	std::string fname;
-	char ch;
+	char ch = 0;
 
 	while ((ch = getopt(argc, argv, "f:o:i:hI")) != -1)
 	{