++

Author: Zainullin Damir

include/ipfixprobe/pluginFactory/pluginFactory.hpp

@@ -21,6 +21,8 @@
 #include <string_view>
 #include <type_traits>
 
+#include "../api.hpp"
+
 namespace ipxp {
 
 /**
@@ -34,14 +36,14 @@ namespace ipxp {
  * @tparam Args The types of arguments that will be passed to the plugin constructors.
  */
 template<typename Base, typename... Args>
-class PluginFactory {
+class IPXP_API PluginFactory {
 public:
 	/**
 	 * @brief Retrieves the singleton instance of `PluginFactory`.
 	 *
 	 * @return A reference to the singleton `PluginFactory` instance.
 	 */
-	static PluginFactory& getInstance()
+	inline static PluginFactory& getInstance()
 	{
 		static PluginFactory instance;
 		return instance;

include/ipfixprobe/processPlugin/directionalField.hpp

@@ -0,0 +1,49 @@
+#pragma once
+
+#include <cstdint>
+
+class Direction {
+private:
+	enum class Value : std::size_t {Forward, Reverse};
+
+	constexpr Direction(const Value value) noexcept 
+	: m_value(value) {}
+
+public:
+	const static Direction Forward;
+	const static Direction Reverse;
+
+	constexpr Direction(const bool value) noexcept 
+	: m_value(static_cast<Value>(value)) {}
+
+	constexpr operator bool() const noexcept 
+	{
+		return static_cast<bool>(m_value);
+	}
+
+	constexpr Direction operator!() const noexcept
+	{
+		return Direction(!static_cast<bool>(m_value));
+	}
+
+private:
+	Value m_value;
+};
+
+inline const Direction Direction::Forward = Direction(Value::Forward);
+inline const Direction Direction::Reverse = Direction(Value::Reverse);
+
+template<typename T>
+struct DirectionalField {
+	T values[2]{};
+
+	constexpr T& operator[](const Direction d) 
+	{ 
+		return values[static_cast<bool>(d)];
+	}
+
+	constexpr const T& operator[](const Direction d) const 
+	{
+		return values[static_cast<bool>(d)];
+	}
+};

include/ipfixprobe/processPlugin/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

include/ipfixprobe/processPlugin/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

include/ipfixprobe/processPlugin/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