buffered reader and writer

.clangd

@@ -0,0 +1,2 @@
+CompileFlags:
+  Add: [-std=c++17]

main.cpp

@@ -1,4 +1,5 @@
 #include "config.hpp"
+#include "reader.hpp"
 #include "record.hpp"
 #include <fstream>
 #include <iostream>

makefile

@@ -1,4 +1,4 @@
-CFLAGS = -g -lc++
+CFLAGS = -g -lc++ -std=c++17
 
 build/main: main.cpp build
 	clang $(CFLAGS) main.cpp -o build/main

reader.hpp

@@ -0,0 +1,78 @@
+#pragma once
+#include "record.hpp"
+#include <istream>
+#include <optional>
+#include <vector>
+
+class Reader {
+private:
+    std::vector<Record> read_buffer;
+    std::istream& input_stream;
+    size_t buffer_size;
+    size_t total_reads_count;
+    int last_element_idx; // last valid element in buffer
+    int current_idx; // current reading position
+
+    // returns true if at least one record was returned
+    bool refill_buffer()
+    {
+        last_element_idx = -1;
+        current_idx = 0;
+
+        for (size_t i = 0; i < buffer_size; i++) {
+            if (!(input_stream >> read_buffer[i])) {
+                break;
+            }
+            last_element_idx = static_cast<int>(i);
+        }
+
+        return last_element_idx >= 0;
+    }
+
+public:
+    explicit Reader(std::istream& input_stream, size_t buffer_size = 8)
+        : read_buffer(buffer_size)
+        , input_stream(input_stream)
+        , buffer_size(buffer_size)
+        , total_reads_count(0)
+        , last_element_idx(-1)
+        , current_idx(0)
+    {
+    }
+
+    std::optional<Record> read()
+    {
+        if (current_idx > last_element_idx) {
+            bool read_new_items = refill_buffer();
+            if (!read_new_items) {
+                return std::nullopt;
+            }
+        }
+
+        Record record = read_buffer[current_idx];
+        current_idx++;
+        total_reads_count++;
+
+        return record;
+    }
+
+    size_t total_reads() const
+    {
+        return total_reads_count;
+    }
+
+    // #todo remove if not used in the end
+    // bool has_more() const
+    // {
+    //     return current_idx <= last_element_idx || !input_stream.eof();
+    // }
+
+    // void reset()
+    // {
+    //     input_stream.clear();
+    //     input_stream.seekg(0);
+    //     last_element_idx = -1;
+    //     current_idx = 0;
+    //     total_reads_count = 0;
+    // }
+};

writer.hpp

@@ -0,0 +1,55 @@
+#pragma once
+#include "record.hpp"
+#include <ostream>
+#include <vector>
+
+class Writer {
+private:
+    std::vector<Record> write_buffer;
+    std::ostream& output_stream;
+    size_t buffer_size;
+    size_t total_writes_count;
+    size_t current_idx; // Current position in buffer
+
+    // returns true on success
+    // doesn't really flush for performace reasons
+    // could be changed to really flush to monitor the impac of amount of writes
+    bool flush_buffer()
+    {
+        for (size_t i = 0; i < current_idx; ++i) {
+            if (!(output_stream << write_buffer[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+public:
+    explicit Writer(std::ostream& output_stream, size_t buffer_size = 8)
+        : write_buffer(buffer_size)
+        , output_stream(output_stream)
+        , buffer_size(buffer_size)
+        , total_writes_count(0)
+        , current_idx(0)
+    {
+    }
+
+    bool write(const Record& record)
+    {
+        write_buffer[current_idx] = record;
+        current_idx++;
+        total_writes_count++;
+
+        if (current_idx >= buffer_size) {
+            return flush_buffer();
+        }
+
+        return true;
+    }
+
+    size_t total_writes() const
+    {
+        return total_writes_count;
+    }
+};