WIP: Updated API

Author: Pavel Siska

process-new-api/Makefile

@@ -0,0 +1,17 @@
+CXX := g++
+CXXFLAGS := -std=c++20 -Wall -Wextra -pedantic -Wunused -Wconversion -Wsign-conversion -g -fsanitize=address
+INCLUDES := -I/usr/include
+LDFLAGS := -lboost_system -lboost_filesystem
+
+TARGET := ipx
+SRC := main.cpp fieldManager.cpp icmp.cpp
+
+.PHONY: all clean
+
+all: $(TARGET)
+
+$(TARGET): $(SRC)
+	$(CXX) $(CXXFLAGS) $(INCLUDES) $^ -o $@ $(LDFLAGS)
+
+clean:
+	rm -f $(TARGET)

process-new-api/README.md

@@ -0,0 +1,13 @@
+# ICMP Plugin
+
+## Overview
+
+The ICMP plugin extracts ICMP-specific information from IPv4 and IPv6 packets.
+
+## Fields
+
+| Field Name      | Data Type | Description                            |
+|-----------------|-----------|----------------------------------------|
+| ICMP_TYPE       | uint8_t   | ICMP type from the packet              |
+| ICMP_CODE       | uint8_t   | ICMP code from the packet              |
+| ICMP_TYPE_CODE  | uint16_t  | Combined type and code (type \| code)  |

process-new-api/fieldAccessor.hpp

@@ -0,0 +1,118 @@
+/**
+ * @file
+ * @author Pavel Siska <[email protected]>
+ * @brief Accessor templates for scalar and vector fields with type-safe getters.
+ *
+ * This header defines the `ScalarAccessor` and `VectorAccessor` templates, which provide
+ * a type-safe and performant way to access scalar and vector field values from external
+ * data structures using function pointers.
+ *
+ * These accessors encapsulate a getter function pointer to retrieve the value from
+ * a void pointer to the external data, ensuring compile-time type safety via concepts.
+ *
+ * @copyright Copyright (c) 2025 CESNET, z.s.p.o.
+ */
+
+#pragma once
+
+#include "fieldTypeConcepts.hpp"
+
+#include <cassert>
+#include <span>
+
+namespace ipxp {
+
+/**
+ * @brief Accessor for scalar values.
+ *
+ * Provides a mechanism to access a scalar value of type `T` from an external data
+ * structure via a getter function pointer.
+ *
+ * @tparam T Type of scalar value (must satisfy `FlowDataTypeScalar ` concept).
+ */
+template<FlowDataTypeScalar T>
+class ScalarAccessor {
+public:
+	/// Function pointer type returning a scalar value of type T from a data pointer.
+	using GetterFunction = T (*)(const void*);
+
+	/**
+	 * @brief Constructs the ScalarAccessor with a getter function.
+	 *
+	 * @param getterFunction Function pointer used to extract the scalar value.
+	 *
+	 * @note The getter function pointer must not be null.
+	 */
+	explicit constexpr ScalarAccessor(GetterFunction getterFunction)
+		: m_getterFunction(getterFunction)
+	{
+		assert(m_getterFunction && "ScalarAccessor: getter function must not be nullptr");
+	}
+
+	/**
+	 * @brief Retrieves the scalar value by invoking the getter function.
+	 *
+	 * @param data Pointer to the external data structure.
+	 * @return Extracted scalar value of type T.
+	 */
+	[[nodiscard]] T operator()(const void* data) const { return m_getterFunction(data); }
+
+	ScalarAccessor() = delete;
+	ScalarAccessor(const ScalarAccessor&) = default;
+	ScalarAccessor& operator=(const ScalarAccessor&) = default;
+	ScalarAccessor(ScalarAccessor&&) = default;
+	ScalarAccessor& operator=(ScalarAccessor&&) = default;
+
+private:
+	const GetterFunction m_getterFunction;
+};
+
+/**
+ * @brief Accessor for vector values.
+ *
+ * Provides a mechanism to access a span of values of type `T` from an external data
+ * structure via a getter function pointer.
+ *
+ * @tparam T Type of vector element (must satisfy `FlowDataTypeVector` concept).
+ */
+template<FlowDataTypeVector T>
+class VectorAccessor {
+public:
+	/// Function pointer type returning a span of constant values of type T from a data pointer.
+	using GetterFunction = std::span<const T> (*)(const void*);
+
+	/**
+	 * @brief Constructs the VectorAccessor with a getter function.
+	 *
+	 * @param getterFunction Function pointer used to extract the vector span.
+	 *
+	 * @note The getter function pointer must not be null.
+	 */
+	explicit constexpr VectorAccessor(GetterFunction getterFunction)
+		: m_getterFunction(getterFunction)
+	{
+		assert(m_getterFunction && "VectorAccessor: getter function must not be nullptr");
+	}
+
+	/**
+	 * @brief Retrieves the vector span by invoking the getter function.
+	 *
+	 * @param data Pointer to the external data structure.
+	 * @return Extracted span of constant values of type T.
+	 */
+	[[nodiscard]] std::span<const T> operator()(const void* data) const
+	{
+		return m_getterFunction(data);
+	}
+
+	VectorAccessor() = delete;
+	VectorAccessor(const VectorAccessor&) = default;
+	VectorAccessor& operator=(const VectorAccessor&) = default;
+	VectorAccessor(VectorAccessor&&) = default;
+	VectorAccessor& operator=(VectorAccessor&&) = default;
+
+private:
+	const GetterFunction m_getterFunction;
+};
+
+} // namespace ipxp

process-new-api/fieldDescriptor.hpp

@@ -0,0 +1,102 @@
+/**
+ * @file
+ * @author Pavel Siska <[email protected]>
+ * @brief Provides the FieldDescriptor class for accessing field metadata and value getters.
+ *
+ * This class encapsulates information about a field in a FlowRecord, including its
+ * name, group, bit index, and a generic value accessor. It allows checking if the
+ * field is present in a specific FlowRecord. Construction is restricted to FieldManager.
+ *
+ * @copyright Copyright (c) 2025 CESNET, z.s.p.o.
+ */
+
+#pragma once
+
+#include "fieldGenericValueGetter.hpp"
+#include "fieldInfo.hpp"
+#include "flowRecord.hpp"
+
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+namespace ipxp {
+
+/**
+ * @class FieldDescriptor
+ * @brief Read-only access to field metadata and value getters.
+ *
+ * FieldDescriptor represents a single field within a FlowRecord. It provides
+ * information about the field's name, logical group, bit index, and a generic
+ * value accessor. It allows checking if the field is present in a specific
+ * FlowRecord using the `isInRecord()` method.
+ *
+ * Instances are immutable and can only be created by FieldManager, ensuring
+ * controlled registration and consistent state of fields.
+ */
+class FieldDescriptor {
+public:
+	/**
+	 * @brief Returns the name of the field.
+	 * @return Field name as string_view.
+	 */
+	[[nodiscard]]
+	std::string_view getName() const noexcept
+	{
+		return m_fieldInfo.name;
+	}
+
+	/**
+	 * @brief Returns the logical group name of the field.
+	 * @return Group name (e.g., "tcp", "http").
+	 */
+	[[nodiscard]]
+	std::string_view getGroup() const noexcept
+	{
+		return m_fieldInfo.group;
+	}
+
+	/**
+	 * @brief Returns the generic value accessor for the field.
+	 * @return Reference to GenericValueGetter variant.
+	 */
+	[[nodiscard]]
+	const GenericValueGetter& getValueGetter() const noexcept
+	{
+		return m_fieldInfo.getter;
+	}
+
+	/**
+	 * @brief Returns the bit index used to check field presence in FlowRecord.
+	 * @return Bit index as size_t.
+	 */
+	[[nodiscard]]
+	std::size_t getBitIndex() const noexcept
+	{
+		return m_fieldInfo.bitIndex;
+	}
+
+	/**
+	 * @brief Checks whether this field is present in a given FlowRecord.
+	 * @param record Flow record to query.
+	 * @return True if the field is available in the record.
+	 */
+	[[nodiscard]]
+	bool isInRecord(const FlowRecord& record) const
+	{
+		return record.fieldsAvailable.test(m_fieldInfo.bitIndex);
+	}
+
+private:
+	// FieldDescriptor can only be constructed by FieldManager
+	friend class FieldManager;
+
+	explicit FieldDescriptor(FieldInfo fieldInfo)
+		: m_fieldInfo(std::move(fieldInfo))
+	{
+	}
+
+	const FieldInfo m_fieldInfo;
+};
+
+} // namespace ipxp

process-new-api/fieldGenericValueGetter.hpp

@@ -0,0 +1,44 @@
+/**
+ * @file
+ * @author Pavel Siska <[email protected]>
+ * @brief Type-erased variants for scalar and vector field accessors.
+ *
+ * Defines `ScalarValueGetter`, `VectorValueGetter`, and `GenericValueGetter` as `std::variant`
+ * types that hold accessors for all supported scalar and vector field types.
+ *
+ * These variants allow uniform storage and usage of heterogeneous field accessors
+ * without template overhead, enabling runtime polymorphism without virtual functions.
+ *
+ * @see ScalarAccessor
+ * @see VectorAccessor
+ *
+ * @copyright Copyright (c) 2025 CESNET, z.s.p.o.
+ */
+
+#pragma once
+
+#include "fieldAccessor.hpp"
+#include "fieldSupportedTypes.hpp"
+#include "typeUtils.hpp"
+
+namespace ipxp {
+
+/**
+ * @brief Variant holding any scalar field accessor for supported scalar types.
+ */
+using ScalarValueGetter = detail::variant_of_accessors_t<ScalarAccessor, SupportedScalarTypes>;
+
+/**
+ * @brief Variant holding any vector field accessor for supported vector types.
+ */
+using VectorValueGetter = detail::variant_of_accessors_t<VectorAccessor, SupportedVectorTypes>;
+
+/**
+ * @brief Variant holding either a scalar or a vector field accessor.
+ *
+ * Allows storing any supported accessor type in a single variable,
+ * simplifying generic code paths.
+ */
+using GenericValueGetter = std::variant<ScalarValueGetter, VectorValueGetter>;
+
+} // namespace ipxp

process-new-api/fieldHandler.hpp

@@ -0,0 +1,75 @@
+/**
+ * @file
+ * @author Pavel Siska <[email protected]>
+ * @brief Handle representing a single field within a FlowRecord.
+ *
+ * This file defines the FieldHandler class which provides an interface
+ * for marking a field as available or unavailable in a FlowRecord and
+ * querying its presence status.
+ *
+ * @copyright Copyright (c) 2025 CESNET, z.s.p.o.
+ */
+
+#pragma once
+
+#include "flowRecord.hpp"
+
+#include <cstdint>
+
+namespace ipxp {
+
+/**
+ * @brief Represents a handle to a single field within a FlowRecord.
+ *
+ * FieldHandler allows checking whether a field is present in a record
+ * and provides methods to set or clear its presence flag in `FlowRecord::fieldsAvailable`.
+ */
+class FieldHandler {
+public:
+	/**
+	 * @brief Sets the associated bit in the FlowRecord to indicate field availability.
+	 *
+	 * This method modifies the mutable member `fieldsAvailable` of FlowRecord even if
+	 * the FlowRecord instance is const. This is safe and intentional, as the presence
+	 * information is considered logically mutable.
+	 *
+	 * @param record Reference to FlowRecord (can be const, modifies only mutable member).
+	 */
+	void setAsAvailable(const FlowRecord& record) const { record.fieldsAvailable.set(m_bitIndex); }
+
+	/**
+	 * @brief Clears the associated bit in the FlowRecord to indicate field unavailability.
+	 *
+	 * This method modifies the mutable member `fieldsAvailable` of FlowRecord even if
+	 * the FlowRecord instance is const. This is safe and intentional, as the presence
+	 * information is considered logically mutable.
+	 *
+	 * @param record Reference to FlowRecord (can be const, modifies only mutable member).
+	 */
+	void setAsUnavailable(const FlowRecord& record) const
+	{
+		record.fieldsAvailable.reset(m_bitIndex);
+	}
+
+	/**
+	 * @brief Returns the availability status of the field in the given FlowRecord.
+	 */
+	[[nodiscard]]
+	bool getStatus(const FlowRecord& record) const
+	{
+		return record.fieldsAvailable.test(m_bitIndex);
+	}
+
+private:
+	friend class FieldManager;
+
+	/// Constructor used only by FieldManager to create a valid handler.
+	explicit constexpr FieldHandler(std::size_t bitIndex) noexcept
+		: m_bitIndex(bitIndex)
+	{
+	}
+
+	const std::size_t m_bitIndex;
+};
+
+} // namespace ipxp