Add LogEventWithFilterData template class to extend log event classes with processed fields for filtering.

src/clp_ffi_js/ir/LogEventWithFilterData.hpp

@@ -0,0 +1,53 @@
+#ifndef CLP_FFI_JS_IR_LOGEVENTWITHFILTERDATA_HPP
+#define CLP_FFI_JS_IR_LOGEVENTWITHFILTERDATA_HPP
+
+#include <utility>
+
+#include <clp/ir/types.hpp>
+
+#include <clp_ffi_js/constants.hpp>
+
+namespace clp_ffi_js::ir {
+/**
+ * A class which accepts a log event type as a template parameter and provides additional members
+ * for the log level and timestamp. The additional members facilitate log level filtering.
+ * @tparam LogEvent The type of the log event.
+ */
+template <typename LogEvent>
+class LogEventWithFilterData {
+public:
+    // Constructor
+    LogEventWithFilterData(
+            LogEvent log_event,
+            LogLevel log_level,
+            clp::ir::epoch_time_ms_t timestamp
+    )
+            : m_log_event{std::move(log_event)},
+              m_log_level{log_level},
+              m_timestamp{timestamp} {}
+
+    // Disable copy constructor and assignment operator
+    LogEventWithFilterData(LogEventWithFilterData const&) = delete;
+    auto operator=(LogEventWithFilterData const&) -> LogEventWithFilterData& = delete;
+
+    // Default move constructor and assignment operator
+    LogEventWithFilterData(LogEventWithFilterData&&) = default;
+    auto operator=(LogEventWithFilterData&&) -> LogEventWithFilterData& = default;
+
+    // Destructor
+    ~LogEventWithFilterData() = default;
+
+    [[nodiscard]] auto get_log_event() const -> LogEvent const& { return m_log_event; }
+
+    [[nodiscard]] auto get_log_level() const -> LogLevel { return m_log_level; }
+
+    [[nodiscard]] auto get_timestamp() const -> clp::ir::epoch_time_ms_t { return m_timestamp; }
+
+private:
+    LogEvent m_log_event;
+    LogLevel m_log_level;
+    clp::ir::epoch_time_ms_t m_timestamp;
+};
+}  // namespace clp_ffi_js::ir
+
+#endif  // CLP_FFI_JS_IR_LOGEVENTWITHFILTERDATA_HPP

src/clp_ffi_js/ir/UnstructuredIrStreamReader.cpp

@@ -25,8 +25,7 @@
 #include <spdlog/spdlog.h>
 
 #include <clp_ffi_js/ClpFfiJsException.hpp>
-#include <clp_ffi_js/constants.hpp>
-#include <clp_ffi_js/ir/LogEventWithLevel.hpp>
+#include <clp_ffi_js/ir/LogEventWithFilterData.hpp>
 #include <clp_ffi_js/ir/StreamReader.hpp>
 #include <clp_ffi_js/ir/StreamReaderDataContext.hpp>
 
@@ -147,13 +146,12 @@ auto UnstructuredIrStreamReader::deserialize_stream() -> size_t {
             }
         }
 
-        auto log_viewer_event{LogEventWithLevel<four_byte_encoded_variable_t>(
-                log_event.get_timestamp(),
-                log_event.get_utc_offset(),
-                message,
-                log_level
+        auto log_event_with_filter_data{LogEventWithFilterData<UnstructuredLogEvent>(
+                log_event,
+                log_level,
+                log_event.get_timestamp()
         )};
-        m_encoded_log_events.emplace_back(std::move(log_viewer_event));
+        m_encoded_log_events.emplace_back(std::move(log_event_with_filter_data));
     }
     m_stream_reader_data_context.reset(nullptr);
     return m_encoded_log_events.size();
@@ -187,9 +185,13 @@ auto UnstructuredIrStreamReader::decode_range(size_t begin_idx, size_t end_idx,
         } else {
             log_event_idx = i;
         }
-        auto const& log_event{m_encoded_log_events[log_event_idx]};
+        auto const& log_event_with_filter_data{m_encoded_log_events[log_event_idx]};
+        auto const& log_level = log_event_with_filter_data.get_log_level();
+        auto const& timestamp = log_event_with_filter_data.get_timestamp();
 
-        auto const parsed{log_event.get_message().decode_and_unparse()};
+        auto const& unstructured_log_event = log_event_with_filter_data.get_log_event();
+
+        auto const parsed{unstructured_log_event.get_message().decode_and_unparse()};
         if (false == parsed.has_value()) {
             throw ClpFfiJsException{
                     clp::ErrorCode::ErrorCode_Failure,
@@ -200,14 +202,14 @@ auto UnstructuredIrStreamReader::decode_range(size_t begin_idx, size_t end_idx,
         }
         message = parsed.value();
 
-        m_ts_pattern.insert_formatted_timestamp(log_event.get_timestamp(), message);
+        m_ts_pattern.insert_formatted_timestamp(timestamp, message);
 
         EM_ASM(
                 { Emval.toValue($0).push([UTF8ToString($1), $2, $3, $4]); },
                 results.as_handle(),
                 message.c_str(),
-                log_event.get_timestamp(),
-                log_event.get_log_level(),
+                timestamp,
+                log_level,
                 log_event_idx + 1
         );
     }

src/clp_ffi_js/ir/UnstructuredIrStreamReader.hpp

@@ -7,18 +7,20 @@
 #include <optional>
 #include <vector>
 
+#include <clp/ir/LogEvent.hpp>
 #include <clp/ir/LogEventDeserializer.hpp>
 #include <clp/ir/types.hpp>
 #include <clp/TimestampPattern.hpp>
 #include <emscripten/val.h>
 
-#include <clp_ffi_js/ir/LogEventWithLevel.hpp>
+#include <clp_ffi_js/ir/LogEventWithFilterData.hpp>
 #include <clp_ffi_js/ir/StreamReader.hpp>
 #include <clp_ffi_js/ir/StreamReaderDataContext.hpp>
 
 namespace clp_ffi_js::ir {
 using clp::ir::four_byte_encoded_variable_t;
 using UnstructuredIrDeserializer = clp::ir::LogEventDeserializer<four_byte_encoded_variable_t>;
+using UnstructuredLogEvent = clp::ir::LogEvent<four_byte_encoded_variable_t>;
 
 /**
  * Mapping between an index in the filtered log events collection to an index in the unfiltered
@@ -85,7 +87,7 @@ class UnstructuredIrStreamReader : public StreamReader {
     );
 
     // Variables
-    std::vector<LogEventWithLevel<four_byte_encoded_variable_t>> m_encoded_log_events;
+    std::vector<LogEventWithFilterData<UnstructuredLogEvent>> m_encoded_log_events;
     std::unique_ptr<StreamReaderDataContext<UnstructuredIrDeserializer>>
             m_stream_reader_data_context;
     FilteredLogEventsMap m_filtered_log_event_map;