WARNING: THIS SITE IS A MIRROR OF GITHUB.COM / IT CANNOT LOGIN OR REGISTER ACCOUNTS / THE CONTENTS ARE PROVIDED AS-IS / THIS SITE ASSUMES NO RESPONSIBILITY FOR ANY DISPLAYED CONTENT OR LINKS / IF YOU FOUND SOMETHING MAY NOT GOOD FOR EVERYONE, CONTACT ADMIN AT ilovescratch@foxmail.com
Skip to content

Commit 13cca09

Browse files
jaroslavpesekjaroslavpesek
authored
Merge pull request #71 from Tomas-Vrana/field_classifier_dev
Field classifier dev
2 parents 3b24497 + 636df2a commit 13cca09

File tree

5 files changed

+252
-154
lines changed

5 files changed

+252
-154
lines changed

‎modules/fieldClassifier/src/fieldClassifier.cpp‎

Lines changed: 204 additions & 125 deletions
Original file line numberDiff line numberDiff line change
@@ -213,6 +213,48 @@ void FieldClassifier::getUnirecIdsForDirection(const std::string& prefix, IDMap&
213213
idMap.at(fieldName) = idField;
214214
}
215215
}
216+
217+
void FieldClassifier::getUnirecIdsForInputFields(std::string& templateStr)
218+
{
219+
m_inputFieldIds.clear();
220+
m_inputFieldTypes.clear();
221+
// split template to vector by commas
222+
std::vector<std::string> templateFields;
223+
size_t pos = 0;
224+
std::string strCopy = templateStr;
225+
if (templateStr.back() != ',') {
226+
strCopy += ','; // Add a trailing comma to ensure the last field is processed
227+
}
228+
while ((pos = strCopy.find(',')) != std::string::npos) {
229+
// Extract the field
230+
std::string field = strCopy.substr(0, pos);
231+
strCopy.erase(0, pos + 1);
232+
if (!field.empty()) { // ignore empty fields
233+
templateFields.push_back(field);
234+
}
235+
}
236+
for (const auto& field : templateFields) {
237+
// split field by space to get field name
238+
size_t spacePos = field.find(' ');
239+
if (spacePos == std::string::npos) {
240+
throw std::runtime_error(
241+
"FieldClassifier: Invalid Unirec field format in template: " + field);
242+
}
243+
std::string fieldName = field.substr(spacePos + 1);
244+
std::string fieldType = field.substr(0, spacePos);
245+
246+
auto fieldId = static_cast<ur_field_id_t>(ur_get_id_by_name(fieldName.c_str()));
247+
if (fieldId == UR_E_INVALID_NAME) {
248+
throw std::runtime_error("FieldClassifier: Invalid Unirec field name: " + fieldName);
249+
}
250+
m_inputFieldIds.push_back(fieldId);
251+
if (m_UnirecTypeMap.find(fieldType) == m_UnirecTypeMap.end()) {
252+
throw std::runtime_error("FieldClassifier: Invalid Unirec field type: " + fieldType);
253+
}
254+
m_inputFieldTypes.push_back(m_UnirecTypeMap.at(fieldType));
255+
}
256+
}
257+
216258
void FieldClassifier::getUnirecIds()
217259
{
218260
// get Unirec field IDs for source and destination IP fields
@@ -285,138 +327,175 @@ void FieldClassifier::loadIP(
285327
}
286328
void FieldClassifier::fillInputFieldsToOutput(
287329
std::optional<Nemea::UnirecRecordView>& input,
288-
std::optional<Nemea::UnirecRecord>& output,
289-
std::string& templateStr)
330+
std::optional<Nemea::UnirecRecord>& output)
290331

291332
{
292-
// split template to vector by commas
293-
std::vector<std::string> templateFields;
294-
size_t pos = 0;
295-
std::string strCopy = templateStr;
296-
if (templateStr.back() != ',') {
297-
strCopy += ','; // Add a trailing comma to ensure the last field is processed
298-
}
299-
while ((pos = strCopy.find(',')) != std::string::npos) {
300-
// Extract the field
301-
std::string field = strCopy.substr(0, pos);
302-
strCopy.erase(0, pos + 1);
303-
if (!field.empty()) { // ignore empty fields
304-
templateFields.push_back(field);
333+
unsigned long size = m_inputFieldIds.size();
334+
for (unsigned long i = 0; i < size; i++) {
335+
auto fieldId = m_inputFieldIds[i];
336+
auto fieldTypeIt = m_inputFieldTypes[i];
337+
338+
switch (fieldTypeIt) {
339+
case DataType::STRING: {
340+
auto value = input->getFieldAsType<std::string>(fieldId);
341+
output->setFieldFromType<std::string>(value, fieldId);
342+
break;
305343
}
306-
}
307-
// for each field, get data from input and set to output
308-
for (const auto& field : templateFields) {
309-
// split field by space to get field name
310-
size_t spacePos = field.find(' ');
311-
if (spacePos == std::string::npos) {
312-
throw std::runtime_error(
313-
"FieldClassifier: Invalid Unirec field format in template: " + field);
344+
case DataType::UINT8: {
345+
auto value = input->getFieldAsType<uint8_t>(fieldId);
346+
output->setFieldFromType<uint8_t>(value, fieldId);
347+
break;
314348
}
315-
std::string fieldName = field.substr(spacePos + 1);
316-
std::string fieldType = field.substr(0, spacePos);
317-
318-
auto fieldId = static_cast<ur_field_id_t>(ur_get_id_by_name(fieldName.c_str()));
319-
if (fieldId == UR_E_INVALID_NAME) {
320-
throw std::runtime_error("FieldClassifier: Invalid Unirec field name: " + fieldName);
349+
case DataType::UINT16: {
350+
auto value = input->getFieldAsType<uint16_t>(fieldId);
351+
output->setFieldFromType<uint16_t>(value, fieldId);
352+
break;
321353
}
322-
try {
323-
if (fieldType == "string") {
324-
auto value = input->getFieldAsType<std::string>(fieldId);
325-
output->setFieldFromType<std::string>(value, fieldId);
326-
} else if (fieldType == "uint8") {
327-
auto value = input->getFieldAsType<uint8_t>(fieldId);
328-
output->setFieldFromType<uint8_t>(value, fieldId);
329-
} else if (fieldType == "uint16") {
330-
auto value = input->getFieldAsType<uint16_t>(fieldId);
331-
output->setFieldFromType<uint16_t>(value, fieldId);
332-
} else if (fieldType == "uint32") {
333-
auto value = input->getFieldAsType<uint32_t>(fieldId);
334-
output->setFieldFromType<uint32_t>(value, fieldId);
335-
} else if (fieldType == "uint64") {
336-
auto value = input->getFieldAsType<uint64_t>(fieldId);
337-
output->setFieldFromType<uint64_t>(value, fieldId);
338-
} else if (fieldType == "ipaddr") {
339-
auto value = input->getFieldAsType<Nemea::IpAddress>(fieldId);
340-
output->setFieldFromType<Nemea::IpAddress>(value, fieldId);
341-
} else if (fieldType == "int8") {
342-
auto value = input->getFieldAsType<int8_t>(fieldId);
343-
output->setFieldFromType<int8_t>(value, fieldId);
344-
} else if (fieldType == "int16") {
345-
auto value = input->getFieldAsType<int16_t>(fieldId);
346-
output->setFieldFromType<int16_t>(value, fieldId);
347-
} else if (fieldType == "int32") {
348-
auto value = input->getFieldAsType<int32_t>(fieldId);
349-
output->setFieldFromType<int32_t>(value, fieldId);
350-
} else if (fieldType == "int64") {
351-
auto value = input->getFieldAsType<int64_t>(fieldId);
352-
output->setFieldFromType<int64_t>(value, fieldId);
353-
} else if (fieldType == "char") {
354-
auto value = input->getFieldAsType<char>(fieldId);
355-
output->setFieldFromType<char>(value, fieldId);
356-
} else if (fieldType == "float") {
357-
auto value = input->getFieldAsType<float>(fieldId);
358-
output->setFieldFromType<float>(value, fieldId);
359-
} else if (fieldType == "double") {
360-
auto value = input->getFieldAsType<double>(fieldId);
361-
output->setFieldFromType<double>(value, fieldId);
362-
} else if (fieldType == "macaddr") {
363-
auto value = input->getFieldAsType<Nemea::MacAddress>(fieldId);
364-
output->setFieldFromType<Nemea::MacAddress>(value, fieldId);
365-
} else if (fieldType == "time") {
366-
auto value = input->getFieldAsType<Nemea::UrTime>(fieldId);
367-
output->setFieldFromType<Nemea::UrTime>(value, fieldId);
368-
//} else if (fieldType == "bytes") {
369-
// Nemea::UnirecArray<std::byte> const arr
370-
// = input->getFieldAsUnirecArray<std::byte>(fieldId);
371-
// output->setFieldFromUnirecArray<std::byte>(arr, fieldId);
372-
} else if (fieldType == "int8*") {
373-
Nemea::UnirecArray<int8_t> const arr
374-
= input->getFieldAsUnirecArray<int8_t>(fieldId);
375-
output->setFieldFromUnirecArray<int8_t>(arr, fieldId);
376-
} else if (fieldType == "int16*") {
377-
Nemea::UnirecArray<int16_t> const arr
378-
= input->getFieldAsUnirecArray<int16_t>(fieldId);
379-
output->setFieldFromUnirecArray<int16_t>(arr, fieldId);
380-
} else if (fieldType == "int32*") {
381-
Nemea::UnirecArray<int32_t> const arr
382-
= input->getFieldAsUnirecArray<int32_t>(fieldId);
383-
output->setFieldFromUnirecArray<int32_t>(arr, fieldId);
384-
} else if (fieldType == "int64*") {
385-
Nemea::UnirecArray<int64_t> const arr
386-
= input->getFieldAsUnirecArray<int64_t>(fieldId);
387-
output->setFieldFromUnirecArray<int64_t>(arr, fieldId);
388-
} else if (fieldType == "uint8*") {
389-
Nemea::UnirecArray<uint8_t> const arr
390-
= input->getFieldAsUnirecArray<uint8_t>(fieldId);
391-
output->setFieldFromUnirecArray<uint8_t>(arr, fieldId);
392-
} else if (fieldType == "uint16*") {
393-
Nemea::UnirecArray<uint16_t> const arr
394-
= input->getFieldAsUnirecArray<uint16_t>(fieldId);
395-
output->setFieldFromUnirecArray<uint16_t>(arr, fieldId);
396-
} else if (fieldType == "uint32*") {
397-
Nemea::UnirecArray<uint32_t> const arr
398-
= input->getFieldAsUnirecArray<uint32_t>(fieldId);
399-
output->setFieldFromUnirecArray<uint32_t>(arr, fieldId);
400-
} else if (fieldType == "uint64*") {
401-
Nemea::UnirecArray<uint64_t> const arr
402-
= input->getFieldAsUnirecArray<uint64_t>(fieldId);
403-
output->setFieldFromUnirecArray<uint64_t>(arr, fieldId);
404-
} else if (fieldType == "float*") {
405-
Nemea::UnirecArray<float> const arr = input->getFieldAsUnirecArray<float>(fieldId);
406-
output->setFieldFromUnirecArray<float>(arr, fieldId);
407-
} else if (fieldType == "double*") {
408-
Nemea::UnirecArray<double> const arr
409-
= input->getFieldAsUnirecArray<double>(fieldId);
410-
output->setFieldFromUnirecArray<double>(arr, fieldId);
411-
} else {
412-
throw std::runtime_error(
413-
"FieldClassifier: Unsupported Unirec field type in template: " + fieldType);
414-
}
354+
case DataType::UINT32: {
355+
auto value = input->getFieldAsType<uint32_t>(fieldId);
356+
output->setFieldFromType<uint32_t>(value, fieldId);
357+
break;
358+
}
359+
case DataType::UINT64: {
360+
auto value = input->getFieldAsType<uint64_t>(fieldId);
361+
output->setFieldFromType<uint64_t>(value, fieldId);
362+
break;
363+
}
364+
case DataType::IPADDR: {
365+
auto value = input->getFieldAsType<Nemea::IpAddress>(fieldId);
366+
output->setFieldFromType<Nemea::IpAddress>(value, fieldId);
367+
break;
368+
}
369+
case DataType::INT8: {
370+
auto value = input->getFieldAsType<int8_t>(fieldId);
371+
output->setFieldFromType<int8_t>(value, fieldId);
372+
break;
373+
}
374+
case DataType::INT16: {
375+
auto value = input->getFieldAsType<int16_t>(fieldId);
376+
output->setFieldFromType<int16_t>(value, fieldId);
377+
break;
378+
}
379+
case DataType::INT32: {
380+
auto value = input->getFieldAsType<int32_t>(fieldId);
381+
output->setFieldFromType<int32_t>(value, fieldId);
382+
break;
383+
}
384+
case DataType::INT64: {
385+
auto value = input->getFieldAsType<int64_t>(fieldId);
386+
output->setFieldFromType<int64_t>(value, fieldId);
387+
break;
388+
}
389+
case DataType::CHAR: {
390+
auto value = input->getFieldAsType<char>(fieldId);
391+
output->setFieldFromType<char>(value, fieldId);
392+
break;
393+
}
394+
case DataType::FLOAT: {
395+
auto value = input->getFieldAsType<float>(fieldId);
396+
output->setFieldFromType<float>(value, fieldId);
397+
break;
398+
}
399+
case DataType::DOUBLE: {
400+
auto value = input->getFieldAsType<double>(fieldId);
401+
output->setFieldFromType<double>(value, fieldId);
402+
break;
403+
}
404+
case DataType::MACADDR: {
405+
auto value = input->getFieldAsType<Nemea::MacAddress>(fieldId);
406+
output->setFieldFromType<Nemea::MacAddress>(value, fieldId);
407+
break;
408+
}
409+
case DataType::TIME: {
410+
auto value = input->getFieldAsType<Nemea::UrTime>(fieldId);
411+
output->setFieldFromType<Nemea::UrTime>(value, fieldId);
412+
break;
413+
}
414+
case DataType::BYTES: {
415+
// Nemea::UnirecArray<std::byte> const arr
416+
// = input->getFieldAsUnirecArray<std::byte>(fieldId);
417+
// output->setFieldFromUnirecArray<std::byte>(arr, fieldId);
415418

416-
} catch (const std::exception& ex) {
419+
// std::byte value = input->getFieldAsType<std::byte>(fieldId);
420+
// output->setFieldFromType<std::byte>(value, fieldId);
421+
422+
break;
423+
}
424+
case DataType::A_INT8: {
425+
Nemea::UnirecArray<int8_t> const arr = input->getFieldAsUnirecArray<int8_t>(fieldId);
426+
output->setFieldFromUnirecArray<int8_t>(arr, fieldId);
427+
break;
428+
}
429+
case DataType::A_INT16: {
430+
Nemea::UnirecArray<int16_t> const arr = input->getFieldAsUnirecArray<int16_t>(fieldId);
431+
output->setFieldFromUnirecArray<int16_t>(arr, fieldId);
432+
break;
433+
}
434+
case DataType::A_INT32: {
435+
Nemea::UnirecArray<int32_t> const arr = input->getFieldAsUnirecArray<int32_t>(fieldId);
436+
output->setFieldFromUnirecArray<int32_t>(arr, fieldId);
437+
break;
438+
}
439+
case DataType::A_INT64: {
440+
Nemea::UnirecArray<int64_t> const arr = input->getFieldAsUnirecArray<int64_t>(fieldId);
441+
output->setFieldFromUnirecArray<int64_t>(arr, fieldId);
442+
break;
443+
}
444+
case DataType::A_UINT8: {
445+
Nemea::UnirecArray<uint8_t> const arr = input->getFieldAsUnirecArray<uint8_t>(fieldId);
446+
output->setFieldFromUnirecArray<uint8_t>(arr, fieldId);
447+
break;
448+
}
449+
case DataType::A_UINT16: {
450+
Nemea::UnirecArray<uint16_t> const arr
451+
= input->getFieldAsUnirecArray<uint16_t>(fieldId);
452+
output->setFieldFromUnirecArray<uint16_t>(arr, fieldId);
453+
break;
454+
}
455+
case DataType::A_UINT32: {
456+
Nemea::UnirecArray<uint32_t> const arr
457+
= input->getFieldAsUnirecArray<uint32_t>(fieldId);
458+
output->setFieldFromUnirecArray<uint32_t>(arr, fieldId);
459+
break;
460+
}
461+
case DataType::A_UINT64: {
462+
Nemea::UnirecArray<uint64_t> const arr
463+
= input->getFieldAsUnirecArray<uint64_t>(fieldId);
464+
output->setFieldFromUnirecArray<uint64_t>(arr, fieldId);
465+
break;
466+
}
467+
case DataType::A_FLOAT: {
468+
Nemea::UnirecArray<float> const arr = input->getFieldAsUnirecArray<float>(fieldId);
469+
output->setFieldFromUnirecArray<float>(arr, fieldId);
470+
break;
471+
}
472+
case DataType::A_DOUBLE: {
473+
Nemea::UnirecArray<double> const arr = input->getFieldAsUnirecArray<double>(fieldId);
474+
output->setFieldFromUnirecArray<double>(arr, fieldId);
475+
break;
476+
}
477+
case DataType::A_IP: {
478+
Nemea::UnirecArray<Nemea::IpAddress> const arr
479+
= input->getFieldAsUnirecArray<Nemea::IpAddress>(fieldId);
480+
output->setFieldFromUnirecArray<Nemea::IpAddress>(arr, fieldId);
481+
break;
482+
}
483+
case DataType::A_MAC: {
484+
Nemea::UnirecArray<Nemea::MacAddress> const arr
485+
= input->getFieldAsUnirecArray<Nemea::MacAddress>(fieldId);
486+
output->setFieldFromUnirecArray<Nemea::MacAddress>(arr, fieldId);
487+
break;
488+
}
489+
case DataType::A_TIME: {
490+
Nemea::UnirecArray<Nemea::UrTime> const arr
491+
= input->getFieldAsUnirecArray<Nemea::UrTime>(fieldId);
492+
output->setFieldFromUnirecArray<Nemea::UrTime>(arr, fieldId);
493+
break;
494+
}
495+
default:
417496
throw std::runtime_error(
418-
std::string("FieldClassifier: Unable to copy field '") + field
419-
+ "' from input to output Unirec record: " + ex.what());
497+
"FieldClassifier: Unsupported Unirec field type for field ID: "
498+
+ std::to_string(fieldId));
420499
}
421500
}
422501
}

‎modules/fieldClassifier/src/fieldClassifier.hpp‎

Lines changed: 25 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -76,10 +76,12 @@ class FieldClassifier {
7676
*/
7777
void handleParams(int argc, char** argv, argparse::ArgumentParser& parser);
7878

79+
void getUnirecIdsForInputFields(std::string& templateStr);
80+
7981
void fillInputFieldsToOutput(
8082
std::optional<Nemea::UnirecRecordView>& input,
81-
std::optional<Nemea::UnirecRecord>& output,
82-
std::string& templateStr);
83+
std::optional<Nemea::UnirecRecord>& output);
84+
ur_template_t* templateStringAll;
8385

8486
private:
8587
std::vector<class Plugin*> m_plugins = g_PLUGINS;
@@ -107,6 +109,9 @@ class FieldClassifier {
107109

108110
std::string m_templateStr;
109111

112+
std::vector<ur_field_id_t> m_inputFieldIds;
113+
std::vector<DataType> m_inputFieldTypes;
114+
110115
std::string getIPtoString(const Nemea::IpAddress& ipAddr);
111116

112117
void loadIP(
@@ -146,5 +151,23 @@ class FieldClassifier {
146151

147152
void getRequiredFields(const std::string& requiredFields);
148153
// ###################
154+
155+
std::unordered_map<std::string, DataType> m_UnirecTypeMap = {
156+
{"string", DataType::STRING}, {"int8", DataType::INT8},
157+
{"int16", DataType::INT16}, {"int32", DataType::INT32},
158+
{"int64", DataType::INT64}, {"uint8", DataType::UINT8},
159+
{"uint16", DataType::UINT16}, {"uint32", DataType::UINT32},
160+
{"uint64", DataType::UINT64}, {"char", DataType::CHAR},
161+
{"float", DataType::FLOAT}, {"double", DataType::DOUBLE},
162+
{"ipaddr", DataType::IPADDR}, {"macaddr", DataType::MACADDR},
163+
{"bytes", DataType::BYTES}, {"int8*", DataType::A_INT8},
164+
{"int16*", DataType::A_INT16}, {"int32*", DataType::A_INT32},
165+
{"int64*", DataType::A_INT64}, {"uint8*", DataType::A_UINT8},
166+
{"uint16*", DataType::A_UINT16}, {"uint32*", DataType::A_UINT32},
167+
{"uint64*", DataType::A_UINT64}, {"float*", DataType::A_FLOAT},
168+
{"double*", DataType::A_DOUBLE}, {"ipaddr*", DataType::A_IP},
169+
{"time*", DataType::A_TIME}, {"time", DataType::TIME},
170+
{"macaddr*", DataType::A_MAC},
171+
};
149172
};
150173
} // namespace NFieldClassifier

0 commit comments

Comments
 (0)