From c8f34d742033a3528638e5b6e5849ea6108a3848 Mon Sep 17 00:00:00 2001
From: Tomas Vrana <xvranat00@stud.fit.vut.cz>
Date: Wed, 22 Oct 2025 11:52:15 +0000
Subject: [PATCH 1/2] fieldClassifier: bugfix: output unirec did not have
 original data

unirec fields data comming to plugin were not copied to output -> empty
fields. This commit partial fixes this by allowing non array unirec
members to by copied

changelog: Bugfixes in <fieldClassifier>.
---
 .../fieldClassifier/src/fieldClassifier.cpp   | 130 ++++++++++++++++++
 .../fieldClassifier/src/fieldClassifier.hpp   |   5 +
 modules/fieldClassifier/src/main.cpp          |   9 ++
 .../fieldClassifier/src/plugins/plugin.hpp    |   8 +-
 4 files changed, 148 insertions(+), 4 deletions(-)

diff --git a/modules/fieldClassifier/src/fieldClassifier.cpp b/modules/fieldClassifier/src/fieldClassifier.cpp
index 0b4e2ac..c0d5cdd 100644
--- a/modules/fieldClassifier/src/fieldClassifier.cpp
+++ b/modules/fieldClassifier/src/fieldClassifier.cpp
@@ -281,6 +281,136 @@ void FieldClassifier::loadIP(
 			+ ex.what());
 	}
 }
+void FieldClassifier::fillInputFieldsToOutput(
+	std::optional<Nemea::UnirecRecordView>& input,
+	std::optional<Nemea::UnirecRecord>& output,
+	std::string& templateStr)
+{
+	// split template to vector by commas
+	std::vector<std::string> templateFields;
+	size_t pos = 0;
+	std::string strCopy = templateStr;
+	if (templateStr.back() != ',') {
+		strCopy += ','; // Add a trailing comma to ensure the last field is processed
+	}
+	while ((pos = strCopy.find(',')) != std::string::npos) {
+		// Extract the field
+		std::string field = strCopy.substr(0, pos);
+		strCopy.erase(0, pos + 1);
+		if (!field.empty()) { // ignore empty fields
+			templateFields.push_back(field);
+		}
+	}
+	// for each field, get data from input and set to output
+	for (const auto& field : templateFields) {
+		// split field by space to get field name
+		size_t spacePos = field.find(' ');
+		if (spacePos == std::string::npos) {
+			throw std::runtime_error(
+				"FieldClassifier: Invalid Unirec field format in template: " + field);
+		}
+		std::string fieldName = field.substr(spacePos + 1);
+		std::string fieldType = field.substr(0, spacePos);
+
+		auto fieldId = static_cast<ur_field_id_t>(ur_get_id_by_name(fieldName.c_str()));
+		if (fieldId == UR_E_INVALID_NAME) {
+			throw std::runtime_error("FieldClassifier: Invalid Unirec field name: " + fieldName);
+		}
+		try {
+			if (fieldType == "string") {
+				auto value = input->getFieldAsType<std::string>(fieldId);
+				output->setFieldFromType<std::string>(value, fieldId);
+			} else if (fieldType == "uint8") {
+				auto value = input->getFieldAsType<uint8_t>(fieldId);
+				output->setFieldFromType<uint8_t>(value, fieldId);
+			} else if (fieldType == "uint16") {
+				auto value = input->getFieldAsType<uint16_t>(fieldId);
+				output->setFieldFromType<uint16_t>(value, fieldId);
+			} else if (fieldType == "uint32") {
+				auto value = input->getFieldAsType<uint32_t>(fieldId);
+				output->setFieldFromType<uint32_t>(value, fieldId);
+			} else if (fieldType == "uint64") {
+				auto value = input->getFieldAsType<uint64_t>(fieldId);
+				output->setFieldFromType<uint64_t>(value, fieldId);
+			} else if (fieldType == "ipaddr") {
+				auto value = input->getFieldAsType<Nemea::IpAddress>(fieldId);
+				output->setFieldFromType<Nemea::IpAddress>(value, fieldId);
+			} else if (fieldType == "int8") {
+				auto value = input->getFieldAsType<int8_t>(fieldId);
+				output->setFieldFromType<int8_t>(value, fieldId);
+			} else if (fieldType == "int16") {
+				auto value = input->getFieldAsType<int16_t>(fieldId);
+				output->setFieldFromType<int16_t>(value, fieldId);
+			} else if (fieldType == "int32") {
+				auto value = input->getFieldAsType<int32_t>(fieldId);
+				output->setFieldFromType<int32_t>(value, fieldId);
+			} else if (fieldType == "int64") {
+				auto value = input->getFieldAsType<int64_t>(fieldId);
+				output->setFieldFromType<int64_t>(value, fieldId);
+			} else if (fieldType == "char") {
+				auto value = input->getFieldAsType<char>(fieldId);
+				output->setFieldFromType<char>(value, fieldId);
+			} else if (fieldType == "float") {
+				auto value = input->getFieldAsType<float>(fieldId);
+				output->setFieldFromType<float>(value, fieldId);
+			} else if (fieldType == "double") {
+				auto value = input->getFieldAsType<double>(fieldId);
+				output->setFieldFromType<double>(value, fieldId);
+			} else if (fieldType == "macaddr") {
+				auto value = input->getFieldAsType<Nemea::MacAddress>(fieldId);
+				output->setFieldFromType<Nemea::MacAddress>(value, fieldId);
+			} else if (fieldType == "time") {
+				auto value = input->getFieldAsType<Nemea::UrTime>(fieldId);
+				output->setFieldFromType<Nemea::UrTime>(value, fieldId);
+			} else if (fieldType == "bytes") {
+				// Nemea::UnirecArray<std::byte> const arr
+				// 	= input->getFieldAsUnirecArray<std::byte>(fieldId);
+				// output->setFieldFromUnirecArray<std::byte>(arr, fieldId);
+				// TODO: implement
+			} else if (fieldType == "int8*") {
+				// const int8_t* value = input->getFieldAsType<int8_t*>(fieldId);
+				// output->setFieldFromType<int8_t*>((int8_t*) value, fieldId);
+			} else if (fieldType == "int16*") {
+				// auto value = input->getFieldAsUnirecArray<int16_t>(fieldId);
+				// output->setFieldFromUnirecArray<int16_t>(value, fieldId);
+			} else if (fieldType == "int32*") {
+				// auto value = input->getFieldAsUnirecArray<int32_t>(fieldId);
+				// output->setFieldFromUnirecArray<int32_t>(value, fieldId);
+			} else if (fieldType == "int64*") {
+				// auto value = input->getFieldAsUnirecArray<int64_t>(fieldId);
+				// output->setFieldFromUnirecArray<int64_t>(value, fieldId);
+			} else if (fieldType == "uint8*") {
+				// auto value = input->getFieldAsUnirecArray<uint8_t>(fieldId);
+				// output->setFieldFromUnirecArray<uint8_t>(value, fieldId);
+			} else if (fieldType == "uint16*") {
+				// auto value = input->getFieldAsUnirecArray<uint16_t>(fieldId);
+				// output->setFieldFromUnirecArray<uint16_t>(value, fieldId);
+			} else if (fieldType == "uint32*") {
+				// auto value = input->getFieldAsUnirecArray<uint32_t>(fieldId);
+				// output->setFieldFromUnirecArray<uint32_t>(value, fieldId);
+			} else if (fieldType == "uint64*") {
+				// auto value = input->getFieldAsUnirecArray<uint64_t>(fieldId);
+				// output->setFieldFromUnirecArray<uint64_t>(value, fieldId);
+			} else if (fieldType == "time*") {
+				// auto value = input->getFieldAsUnirecArray<Nemea::UrTime>(fieldId);
+				// output->setFieldFromUnirecArray<Nemea::UrTime>(value, fieldId);
+			} else if (fieldType == "float*") {
+				// auto value = input->getFieldAsUnirecArray<float>(fieldId);
+				// output->setFieldFromUnirecArray<float>(value, fieldId);
+			} else if (fieldType == "double*") {
+				// auto value = input->getFieldAsUnirecArray<double>(fieldId);
+				// output->setFieldFromUnirecArray<double>(value, fieldId);
+			} else {
+				// throw std::runtime_error(
+				// 	"FieldClassifier: Unsupported Unirec field type: " + fieldType);
+			}
+		} catch (const std::exception& ex) {
+			throw std::runtime_error(
+				std::string("FieldClassifier: Unable to copy field '") + field
+				+ "' from input to output Unirec record: " + ex.what());
+		}
+	}
+}
 
 void FieldClassifier::getDataFromPlugins(std::optional<Nemea::UnirecRecordView>& unirecView)
 {
diff --git a/modules/fieldClassifier/src/fieldClassifier.hpp b/modules/fieldClassifier/src/fieldClassifier.hpp
index 5dc4ef3..7ed2f8d 100644
--- a/modules/fieldClassifier/src/fieldClassifier.hpp
+++ b/modules/fieldClassifier/src/fieldClassifier.hpp
@@ -76,6 +76,11 @@ class FieldClassifier {
 	 */
 	void handleParams(int argc, char** argv, argparse::ArgumentParser& parser);
 
+	void fillInputFieldsToOutput(
+		std::optional<Nemea::UnirecRecordView>& input,
+		std::optional<Nemea::UnirecRecord>& output,
+		std::string& templateStr);
+
 private:
 	std::vector<class Plugin*> m_plugins = g_PLUGINS;
 
diff --git a/modules/fieldClassifier/src/main.cpp b/modules/fieldClassifier/src/main.cpp
index 31de888..4045d88 100644
--- a/modules/fieldClassifier/src/main.cpp
+++ b/modules/fieldClassifier/src/main.cpp
@@ -62,6 +62,15 @@ static void processNextRecord(
 		throw std::runtime_error(std::string("Unable to create output Unirec record"));
 		return;
 	}
+	auto* templateDef = input.getTemplate();
+	if (templateDef == nullptr) {
+		throw std::runtime_error(std::string("Unable to get template from trap input"));
+	}
+
+	// convert template to string and append new fileds
+	std::string stringTemp = static_cast<std::string>(ur_template_string(templateDef));
+
+	fieldClassifier.fillInputFieldsToOutput(inputUnirecView, unirecRecord, stringTemp);
 
 	// populate Unirec record with data from modules
 	try {
diff --git a/modules/fieldClassifier/src/plugins/plugin.hpp b/modules/fieldClassifier/src/plugins/plugin.hpp
index be8eef8..43e16d0 100644
--- a/modules/fieldClassifier/src/plugins/plugin.hpp
+++ b/modules/fieldClassifier/src/plugins/plugin.hpp
@@ -58,11 +58,11 @@ enum DataType : uint8_t {
 	CHAR,
 	FLOAT,
 	DOUBLE,
-	// IPADDR,
-	// MACADDR,
-	// TIME,
+	IPADDR,
+	MACADDR,
+	TIME,
 	STRING,
-	// BYTES
+	BYTES
 };
 
 /**

From 9ff04603d97d2ad21d3f0d7365099213c868b1b4 Mon Sep 17 00:00:00 2001
From: Tomas Vrana <xvranat00@stud.fit.vut.cz>
Date: Wed, 22 Oct 2025 12:30:45 +0000
Subject: [PATCH 2/2] fieldClassifier: bugfix: Adding support for unirecArrays

changelog: Bugfixes in <fieldClassifier>.
---
 .../fieldClassifier/src/fieldClassifier.cpp   | 65 ++++++++++---------
 1 file changed, 36 insertions(+), 29 deletions(-)

diff --git a/modules/fieldClassifier/src/fieldClassifier.cpp b/modules/fieldClassifier/src/fieldClassifier.cpp
index c0d5cdd..3125d90 100644
--- a/modules/fieldClassifier/src/fieldClassifier.cpp
+++ b/modules/fieldClassifier/src/fieldClassifier.cpp
@@ -285,6 +285,7 @@ void FieldClassifier::fillInputFieldsToOutput(
 	std::optional<Nemea::UnirecRecordView>& input,
 	std::optional<Nemea::UnirecRecord>& output,
 	std::string& templateStr)
+
 {
 	// split template to vector by commas
 	std::vector<std::string> templateFields;
@@ -363,47 +364,53 @@ void FieldClassifier::fillInputFieldsToOutput(
 				auto value = input->getFieldAsType<Nemea::UrTime>(fieldId);
 				output->setFieldFromType<Nemea::UrTime>(value, fieldId);
 			} else if (fieldType == "bytes") {
-				// Nemea::UnirecArray<std::byte> const arr
-				// 	= input->getFieldAsUnirecArray<std::byte>(fieldId);
-				// output->setFieldFromUnirecArray<std::byte>(arr, fieldId);
-				// TODO: implement
+				Nemea::UnirecArray<std::byte> const arr
+					= input->getFieldAsUnirecArray<std::byte>(fieldId);
+				output->setFieldFromUnirecArray<std::byte>(arr, fieldId);
 			} else if (fieldType == "int8*") {
-				// const int8_t* value = input->getFieldAsType<int8_t*>(fieldId);
-				// output->setFieldFromType<int8_t*>((int8_t*) value, fieldId);
+				Nemea::UnirecArray<int8_t> const arr
+					= input->getFieldAsUnirecArray<int8_t>(fieldId);
+				output->setFieldFromUnirecArray<int8_t>(arr, fieldId);
 			} else if (fieldType == "int16*") {
-				// auto value = input->getFieldAsUnirecArray<int16_t>(fieldId);
-				// output->setFieldFromUnirecArray<int16_t>(value, fieldId);
+				Nemea::UnirecArray<int16_t> const arr
+					= input->getFieldAsUnirecArray<int16_t>(fieldId);
+				output->setFieldFromUnirecArray<int16_t>(arr, fieldId);
 			} else if (fieldType == "int32*") {
-				// auto value = input->getFieldAsUnirecArray<int32_t>(fieldId);
-				// output->setFieldFromUnirecArray<int32_t>(value, fieldId);
+				Nemea::UnirecArray<int32_t> const arr
+					= input->getFieldAsUnirecArray<int32_t>(fieldId);
+				output->setFieldFromUnirecArray<int32_t>(arr, fieldId);
 			} else if (fieldType == "int64*") {
-				// auto value = input->getFieldAsUnirecArray<int64_t>(fieldId);
-				// output->setFieldFromUnirecArray<int64_t>(value, fieldId);
+				Nemea::UnirecArray<int64_t> const arr
+					= input->getFieldAsUnirecArray<int64_t>(fieldId);
+				output->setFieldFromUnirecArray<int64_t>(arr, fieldId);
 			} else if (fieldType == "uint8*") {
-				// auto value = input->getFieldAsUnirecArray<uint8_t>(fieldId);
-				// output->setFieldFromUnirecArray<uint8_t>(value, fieldId);
+				Nemea::UnirecArray<uint8_t> const arr
+					= input->getFieldAsUnirecArray<uint8_t>(fieldId);
+				output->setFieldFromUnirecArray<uint8_t>(arr, fieldId);
 			} else if (fieldType == "uint16*") {
-				// auto value = input->getFieldAsUnirecArray<uint16_t>(fieldId);
-				// output->setFieldFromUnirecArray<uint16_t>(value, fieldId);
+				Nemea::UnirecArray<uint16_t> const arr
+					= input->getFieldAsUnirecArray<uint16_t>(fieldId);
+				output->setFieldFromUnirecArray<uint16_t>(arr, fieldId);
 			} else if (fieldType == "uint32*") {
-				// auto value = input->getFieldAsUnirecArray<uint32_t>(fieldId);
-				// output->setFieldFromUnirecArray<uint32_t>(value, fieldId);
+				Nemea::UnirecArray<uint32_t> const arr
+					= input->getFieldAsUnirecArray<uint32_t>(fieldId);
+				output->setFieldFromUnirecArray<uint32_t>(arr, fieldId);
 			} else if (fieldType == "uint64*") {
-				// auto value = input->getFieldAsUnirecArray<uint64_t>(fieldId);
-				// output->setFieldFromUnirecArray<uint64_t>(value, fieldId);
-			} else if (fieldType == "time*") {
-				// auto value = input->getFieldAsUnirecArray<Nemea::UrTime>(fieldId);
-				// output->setFieldFromUnirecArray<Nemea::UrTime>(value, fieldId);
+				Nemea::UnirecArray<uint64_t> const arr
+					= input->getFieldAsUnirecArray<uint64_t>(fieldId);
+				output->setFieldFromUnirecArray<uint64_t>(arr, fieldId);
 			} else if (fieldType == "float*") {
-				// auto value = input->getFieldAsUnirecArray<float>(fieldId);
-				// output->setFieldFromUnirecArray<float>(value, fieldId);
+				Nemea::UnirecArray<float> const arr = input->getFieldAsUnirecArray<float>(fieldId);
+				output->setFieldFromUnirecArray<float>(arr, fieldId);
 			} else if (fieldType == "double*") {
-				// auto value = input->getFieldAsUnirecArray<double>(fieldId);
-				// output->setFieldFromUnirecArray<double>(value, fieldId);
+				Nemea::UnirecArray<double> const arr
+					= input->getFieldAsUnirecArray<double>(fieldId);
+				output->setFieldFromUnirecArray<double>(arr, fieldId);
 			} else {
-				// throw std::runtime_error(
-				// 	"FieldClassifier: Unsupported Unirec field type: " + fieldType);
+				throw std::runtime_error(
+					"FieldClassifier: Unsupported Unirec field type in template: " + fieldType);
 			}
+
 		} catch (const std::exception& ex) {
 			throw std::runtime_error(
 				std::string("FieldClassifier: Unable to copy field '") + field