ffi: Add class for key-value pair log events.

components/core/CMakeLists.txt

@@ -320,6 +320,8 @@ set(SOURCE_FILES_unitTest
         src/clp/ffi/ir_stream/Serializer.hpp
         src/clp/ffi/ir_stream/utils.cpp
         src/clp/ffi/ir_stream/utils.hpp
+        src/clp/ffi/KeyValuePairLogEvent.cpp
+        src/clp/ffi/KeyValuePairLogEvent.hpp
         src/clp/ffi/SchemaTree.cpp
         src/clp/ffi/SchemaTree.hpp
         src/clp/ffi/SchemaTreeNode.hpp

components/core/src/clp/ffi/KeyValuePairLogEvent.cpp

@@ -0,0 +1,91 @@
+#include "KeyValuePairLogEvent.hpp"
+
+#include <memory>
+#include <string>
+#include <system_error>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
+
+#include <outcome/single-header/outcome.hpp>
+
+#include "../ir/EncodedTextAst.hpp"
+#include "../time_types.hpp"
+#include "SchemaTree.hpp"
+#include "SchemaTreeNode.hpp"
+#include "Value.hpp"
+
+using clp::ir::EightByteEncodedTextAst;
+using clp::ir::FourByteEncodedTextAst;
+using std::string;
+
+namespace clp::ffi {
+namespace {
+/**
+ * @param type
+ * @param value
+ * @return Whether the given schema tree node type matches the given value's type.
+ */
+[[nodiscard]] auto is_valid_value_type(SchemaTreeNode::Type type, Value const& value) -> bool;
+
+auto is_valid_value_type(SchemaTreeNode::Type type, Value const& value) -> bool {
+    switch (type) {
+        case SchemaTreeNode::Type::Obj:
+            return value.is_null();
+        case SchemaTreeNode::Type::Int:
+            return value.is<value_int_t>();
+        case SchemaTreeNode::Type::Float:
+            return value.is<value_float_t>();
+        case SchemaTreeNode::Type::Bool:
+            return value.is<value_bool_t>();
+        case SchemaTreeNode::Type::UnstructuredArray:
+            return value.is<FourByteEncodedTextAst>() || value.is<EightByteEncodedTextAst>();
+        case SchemaTreeNode::Type::Str:
+            return value.is<string>() || value.is<FourByteEncodedTextAst>()
+                   || value.is<EightByteEncodedTextAst>();
+        default:
+            return false;
+    }
+}
+}  // namespace
+
+auto KeyValuePairLogEvent::create(
+        std::shared_ptr<SchemaTree> schema_tree,
+        KeyValuePairs kv_pairs,
+        UtcOffset utc_offset
+) -> OUTCOME_V2_NAMESPACE::std_result<KeyValuePairLogEvent> {
+    std::unordered_map<SchemaTreeNode::id_t, std::unordered_set<string>> key_sets;
+    try {
+        for (auto const& [key_id, value] : kv_pairs) {
+            if (SchemaTree::cRootId == key_id) {
+                return std::errc::protocol_error;
+            }
+
+            auto const& node{schema_tree->get_node(key_id)};
+            auto const type{node.get_type()};
+            if (false == value.has_value()) {
+                // Empty value
+                if (SchemaTreeNode::Type::Obj != type) {
+                    return std::errc::protocol_error;
+                }
+            } else if (false == is_valid_value_type(type, value.value())) {
+                return std::errc::protocol_error;
+            }
+
+            auto const parent_id{node.get_parent_id()};
+            auto const key_name{node.get_key_name()};
+            if (key_sets.contains(parent_id)) {
+                if (key_sets.at(parent_id).contains({key_name.begin(), key_name.end()})) {
+                    // The key is duplicated
+                    return std::errc::protocol_not_supported;
+                }
+            } else {
+                key_sets.emplace(parent_id, std::unordered_set{string{key_name}});
+            }
+        }
+    } catch (SchemaTree::OperationFailed const& ex) {
+        return std::errc::operation_not_permitted;
+    }
+    return KeyValuePairLogEvent{std::move(schema_tree), std::move(kv_pairs), utc_offset};
+}
+}  // namespace clp::ffi

components/core/src/clp/ffi/KeyValuePairLogEvent.hpp

@@ -0,0 +1,81 @@
+#ifndef CLP_FFI_KEYVALUEPAIRLOGEVENT_HPP
+#define CLP_FFI_KEYVALUEPAIRLOGEVENT_HPP
+
+#include <memory>
+#include <optional>
+#include <unordered_map>
+#include <utility>
+
+#include <outcome/single-header/outcome.hpp>
+
+#include "../time_types.hpp"
+#include "SchemaTree.hpp"
+#include "SchemaTreeNode.hpp"
+#include "Value.hpp"
+
+namespace clp::ffi {
+/**
+ * Class for key-value pair log events. Each key-value pair log event contains the following items:
+ *  - A list of key-value pairs
+ *  - A reference to the schema tree
+ *  - The UTC offset of the current log event
+ */
+class KeyValuePairLogEvent {
+public:
+    // Types
+    using KeyValuePairs = std::unordered_map<SchemaTreeNode::id_t, std::optional<Value>>;
+
+    // Factory functions
+    /**
+     * Creates a key-value pair log event from valid given inputs.
+     * @param schema_tree
+     * @param kv_pairs
+     * @param utc_offset
+     * @return A result containing the key-value pair log event or an error code indicating the
+     * failure:
+     * - std::errc::operation_not_permitted if the key ID doesn't represent a valid node in the
+     *   schema tree.
+     * - std::errc::protocol_error if the schema tree node type doesn't match the value's type.
+     * - std::errc::protocol_not_supported if the same key appears more than once under a parent
+     *   node.
+     */
+    [[nodiscard]] static auto
+    create(std::shared_ptr<SchemaTree> schema_tree, KeyValuePairs kv_pairs, UtcOffset utc_offset
+    ) -> OUTCOME_V2_NAMESPACE::std_result<KeyValuePairLogEvent>;
+
+    // Disable copy constructor and assignment operator
+    KeyValuePairLogEvent(KeyValuePairLogEvent const&) = delete;
+    auto operator=(KeyValuePairLogEvent const&) -> KeyValuePairLogEvent& = delete;
+
+    // Default move constructor and assignment operator
+    KeyValuePairLogEvent(KeyValuePairLogEvent&&) = default;
+    auto operator=(KeyValuePairLogEvent&&) -> KeyValuePairLogEvent& = default;
+
+    // Destructor
+    ~KeyValuePairLogEvent() = default;
+
+    // Methods
+    [[nodiscard]] auto get_schema_tree() const -> SchemaTree const& { return *m_schema_tree; }
+
+    [[nodiscard]] auto get_key_value_pairs() const -> KeyValuePairs const& { return m_kv_pairs; }
+
+    [[nodiscard]] auto get_utc_offset() const -> UtcOffset { return m_utc_offset; }
+
+private:
+    // Constructor
+    KeyValuePairLogEvent(
+            std::shared_ptr<SchemaTree> schema_tree,
+            KeyValuePairs key_value_pairs,
+            UtcOffset utc_offset
+    )
+            : m_schema_tree{std::move(schema_tree)},
+              m_kv_pairs{std::move(key_value_pairs)},
+              m_utc_offset{utc_offset} {}
+
+    std::shared_ptr<SchemaTree> m_schema_tree;
+    KeyValuePairs m_kv_pairs;
+    UtcOffset m_utc_offset{0};
+};
+}  // namespace clp::ffi
+
+#endif  // CLP_FFI_KEYVALUEPAIRLOGEVENT_HPP