Skip to content

fieldClassifier: bugfix: output unirec did not have original data #67

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
jaroslavpesek merged 2 commits into from
Oct 23, 2025
Merged

fieldClassifier: bugfix: output unirec did not have original data #67

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
c8f34d7
fieldClassifier: bugfix: output unirec did not have original data
Tomas-Vrana Oct 22, 2025
9ff0460
fieldClassifier: bugfix: Adding support for unirecArrays
Tomas-Vrana Oct 22, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
137 changes: 137 additions & 0 deletions modules/fieldClassifier/src/fieldClassifier.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -281,6 +281,143 @@ 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);
} else if (fieldType == "int8*") {
Nemea::UnirecArray<int8_t> const arr
= input->getFieldAsUnirecArray<int8_t>(fieldId);
output->setFieldFromUnirecArray<int8_t>(arr, fieldId);
} else if (fieldType == "int16*") {
Nemea::UnirecArray<int16_t> const arr
= input->getFieldAsUnirecArray<int16_t>(fieldId);
output->setFieldFromUnirecArray<int16_t>(arr, fieldId);
} else if (fieldType == "int32*") {
Nemea::UnirecArray<int32_t> const arr
= input->getFieldAsUnirecArray<int32_t>(fieldId);
output->setFieldFromUnirecArray<int32_t>(arr, fieldId);
} else if (fieldType == "int64*") {
Nemea::UnirecArray<int64_t> const arr
= input->getFieldAsUnirecArray<int64_t>(fieldId);
output->setFieldFromUnirecArray<int64_t>(arr, fieldId);
} else if (fieldType == "uint8*") {
Nemea::UnirecArray<uint8_t> const arr
= input->getFieldAsUnirecArray<uint8_t>(fieldId);
output->setFieldFromUnirecArray<uint8_t>(arr, fieldId);
} else if (fieldType == "uint16*") {
Nemea::UnirecArray<uint16_t> const arr
= input->getFieldAsUnirecArray<uint16_t>(fieldId);
output->setFieldFromUnirecArray<uint16_t>(arr, fieldId);
} else if (fieldType == "uint32*") {
Nemea::UnirecArray<uint32_t> const arr
= input->getFieldAsUnirecArray<uint32_t>(fieldId);
output->setFieldFromUnirecArray<uint32_t>(arr, fieldId);
} else if (fieldType == "uint64*") {
Nemea::UnirecArray<uint64_t> const arr
= input->getFieldAsUnirecArray<uint64_t>(fieldId);
output->setFieldFromUnirecArray<uint64_t>(arr, fieldId);
} else if (fieldType == "float*") {
Nemea::UnirecArray<float> const arr = input->getFieldAsUnirecArray<float>(fieldId);
output->setFieldFromUnirecArray<float>(arr, fieldId);
} else if (fieldType == "double*") {
Nemea::UnirecArray<double> const arr
= input->getFieldAsUnirecArray<double>(fieldId);
output->setFieldFromUnirecArray<double>(arr, fieldId);
} else {
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
+ "' from input to output Unirec record: " + ex.what());
}
}
}

void FieldClassifier::getDataFromPlugins(std::optional<Nemea::UnirecRecordView>& unirecView)
{
Expand Down
5 changes: 5 additions & 0 deletions modules/fieldClassifier/src/fieldClassifier.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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;

Expand Down
9 changes: 9 additions & 0 deletions modules/fieldClassifier/src/main.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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 {
Expand Down
8 changes: 4 additions & 4 deletions modules/fieldClassifier/src/plugins/plugin.hpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -58,11 +58,11 @@ enum DataType : uint8_t {
CHAR,
FLOAT,
DOUBLE,
// IPADDR,
// MACADDR,
// TIME,
IPADDR,
MACADDR,
TIME,
STRING,
// BYTES
BYTES
};

/**
Expand Down
Loading