Refactor StreamReaderDataContext to encapsulate readers instead of zstd decompressors; Change its template type to deserializer.

src/clp_ffi_js/ir/StreamReader.cpp

@@ -32,6 +32,7 @@
 
 using namespace std::literals::string_literals;
 using clp::ir::four_byte_encoded_variable_t;
+using clp::ir::LogEventDeserializer;
 
 namespace clp_ffi_js::ir {
 auto StreamReader::create(DataArrayTsType const& data_array) -> StreamReader {
@@ -89,11 +90,12 @@ auto StreamReader::create(DataArrayTsType const& data_array) -> StreamReader {
         };
     }
 
-    StreamReaderDataContext<four_byte_encoded_variable_t> stream_reader_data_context{
-            std::move(data_buffer),
-            std::move(zstd_decompressor),
-            std::move(result.value())
-    };
+    StreamReaderDataContext<LogEventDeserializer<four_byte_encoded_variable_t>>
+            stream_reader_data_context{
+                    std::move(data_buffer),
+                    std::move(zstd_decompressor),
+                    std::move(result.value())
+            };
     return StreamReader{std::move(stream_reader_data_context)};
 }
 
@@ -244,10 +246,11 @@ auto StreamReader::decode_range(size_t begin_idx, size_t end_idx, bool use_filte
 }
 
 StreamReader::StreamReader(
-        StreamReaderDataContext<four_byte_encoded_variable_t>&& stream_reader_data_context
+        StreamReaderDataContext<LogEventDeserializer<four_byte_encoded_variable_t>>&&
+                stream_reader_data_context
 )
         : m_stream_reader_data_context{std::make_unique<
-                  StreamReaderDataContext<four_byte_encoded_variable_t>>(
+                  StreamReaderDataContext<LogEventDeserializer<four_byte_encoded_variable_t>>>(
                   std::move(stream_reader_data_context)
           )},
           m_ts_pattern{m_stream_reader_data_context->get_deserializer().get_timestamp_pattern()} {}

src/clp_ffi_js/ir/StreamReader.hpp

@@ -6,13 +6,16 @@
 #include <optional>
 #include <vector>
 
+#include <clp/ir/LogEventDeserializer.hpp>
 #include <clp/ir/types.hpp>
 #include <clp/TimestampPattern.hpp>
 #include <emscripten/bind.h>
 #include <emscripten/val.h>
 
 #include <clp_ffi_js/ir/LogEventWithLevel.hpp>
 #include <clp_ffi_js/ir/StreamReaderDataContext.hpp>
+using clp::ir::four_byte_encoded_variable_t;
+using clp::ir::LogEventDeserializer;
 
 namespace clp_ffi_js::ir {
 EMSCRIPTEN_DECLARE_VAL_TYPE(DataArrayTsType);
@@ -97,12 +100,14 @@ class StreamReader {
 
 private:
     // Constructor
-    explicit StreamReader(StreamReaderDataContext<clp::ir::four_byte_encoded_variable_t>&&
-                                  stream_reader_data_context);
+    explicit StreamReader(
+            StreamReaderDataContext<LogEventDeserializer<four_byte_encoded_variable_t>>&&
+                    stream_reader_data_context
+    );
 
     // Variables
-    std::vector<LogEventWithLevel<clp::ir::four_byte_encoded_variable_t>> m_encoded_log_events;
-    std::unique_ptr<StreamReaderDataContext<clp::ir::four_byte_encoded_variable_t>>
+    std::vector<LogEventWithLevel<four_byte_encoded_variable_t>> m_encoded_log_events;
+    std::unique_ptr<StreamReaderDataContext<LogEventDeserializer<four_byte_encoded_variable_t>>>
             m_stream_reader_data_context;
     FilteredLogEventsMap m_filtered_log_event_map;
     clp::TimestampPattern m_ts_pattern;

src/clp_ffi_js/ir/StreamReaderDataContext.hpp

@@ -5,28 +5,26 @@
 #include <utility>
 
 #include <clp/Array.hpp>
-#include <clp/ir/LogEventDeserializer.hpp>
-#include <clp/ir/types.hpp>
-#include <clp/streaming_compression/zstd/Decompressor.hpp>
+#include <clp/ReaderInterface.hpp>
 
 namespace clp_ffi_js::ir {
 /**
  * The data context for a `StreamReader`. It encapsulates a chain of the following resources:
- * A `clp::ir::LogEventDeserializer` that reads from a
- * `clp::streaming_compression::zstd::Decompressor`, which in turn reads from a `clp::Array`.
- * @tparam encoded_variable_t Type of encoded variables encoded in the stream.
+ * A CLP deserializer class that reads from a `clp::ReaderInterface`, which in turn reads from a
+ * `clp::Array`.
+ * @tparam deserializer_t Type of deserializer.
  */
-template <typename encoded_variable_t>
+template <typename deserializer_t>
 class StreamReaderDataContext {
 public:
     // Constructors
     StreamReaderDataContext(
             clp::Array<char>&& data_buffer,
-            std::unique_ptr<clp::streaming_compression::zstd::Decompressor>&& zstd_decompressor,
-            clp::ir::LogEventDeserializer<clp::ir::four_byte_encoded_variable_t> deserializer
+            std::unique_ptr<clp::ReaderInterface>&& reader,
+            deserializer_t deserializer
     )
             : m_data_buffer{std::move(data_buffer)},
-              m_zstd_decompressor{std::move(zstd_decompressor)},
+              m_reader{std::move(reader)},
               m_deserializer{std::move(deserializer)} {}
 
     // Disable copy constructor and assignment operator
@@ -41,17 +39,20 @@ class StreamReaderDataContext {
     ~StreamReaderDataContext() = default;
 
     // Methods
+    /**
+     * @return A reference to the reader.
+     */
+    [[nodiscard]] auto get_reader() -> clp::ReaderInterface& { return *m_reader; }
+
     /**
      * @return A reference to the deserializer.
      */
-    [[nodiscard]] auto get_deserializer() -> clp::ir::LogEventDeserializer<encoded_variable_t>& {
-        return m_deserializer;
-    }
+    [[nodiscard]] auto get_deserializer() -> deserializer_t& { return m_deserializer; }
 
 private:
     clp::Array<char> m_data_buffer;
-    std::unique_ptr<clp::streaming_compression::zstd::Decompressor> m_zstd_decompressor;
-    clp::ir::LogEventDeserializer<encoded_variable_t> m_deserializer;
+    std::unique_ptr<clp::ReaderInterface> m_reader;
+    deserializer_t m_deserializer;
 };
 }  // namespace clp_ffi_js::ir