1 files changed, 161 insertions, 0 deletions
diff --git a/src/buffered_file.cpp b/src/buffered_file.cpp
new file mode 100644
index 0000000..f5eb863
--- /dev/null
+++ b/src/buffered_file.cpp
@@ -0,0 +1,161 @@
+/* Copyright 2024 Ján Sučan <jan@jansucan.com>
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "buffered_file.h"
+#include "exception.h"
+
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+
+BufferedFileReader::BufferedFileReader(std::filesystem::path path,
+                                       size_t buffer_capacity)
+    : m_buffer_offset(0), m_buffer_capacity(buffer_capacity)
+{
+    m_file.open(path, std::ifstream::in | std::ifstream::binary);
+    if (!m_file) {
+        throw BufferedFileError("cannot open input file");
+    }
+
+    try {
+        m_buffer = std::make_unique<char[]>(m_buffer_capacity);
+    } catch (const std::bad_alloc &e) {
+        throw BufferedFileError("cannot allocate buffer for input file data");
+    }
+
+    refill_buffer();
+};
+
+size_t
+BufferedFileReader::read(char *data, size_t data_size)
+{
+    const size_t size_left = m_buffer_size - m_buffer_offset;
+    if (data_size <= size_left) {
+        return read_buffer(data, data_size);
+    } else {
+        const size_t size_outside_buffer = data_size - size_left;
+        read_buffer(data, size_left);
+        const size_t read_outside =
+            read_file(data + size_left, size_outside_buffer);
+        refill_buffer();
+        return size_left + read_outside;
+    }
+};
+
+size_t
+BufferedFileReader::read_buffer(char *data, size_t data_size)
+{
+    // Assumes that the caller makes sure there is enough data in the buffer
+    // to read
+    memcpy(data, reinterpret_cast<char *>(m_buffer.get()) + m_buffer_offset,
+           data_size);
+    m_buffer_offset += data_size;
+    return data_size;
+};
+
+void
+BufferedFileReader::refill_buffer()
+{
+    m_buffer_size = read_file(m_buffer.get(), m_buffer_capacity);
+    m_buffer_offset = 0;
+};
+
+size_t
+BufferedFileReader::read_file(char *data, size_t data_size)
+{
+    m_file.read(data, data_size);
+
+    if (!m_file.good() && !m_file.eof()) {
+        throw BufferedFileError("cannot read from file");
+    }
+
+    return m_file.gcount();
+};
+
+BufferedFileWriter::BufferedFileWriter(std::filesystem::path path,
+                                       size_t buffer_capacity)
+    : m_buffer_size(0), m_buffer_capacity(buffer_capacity)
+{
+    /* When backing up, the output file is truncated to hold the
+     * new data
+     */
+    m_file.open(path, std::ifstream::out | std::ifstream::trunc |
+                          std::ifstream::binary);
+    if (!m_file) {
+        throw BufferedFileError("cannot open output file");
+    }
+
+    try {
+        m_buffer = std::make_unique<char[]>(m_buffer_capacity);
+    } catch (const std::bad_alloc &e) {
+        throw BufferedFileError("cannot allocate buffer for output file data");
+    }
+};
+BufferedFileWriter::~BufferedFileWriter() { flush_buffer(); };
+
+void
+BufferedFileWriter::write(const char *data, size_t data_size)
+{
+    size_t free{m_buffer_capacity - m_buffer_size};
+    if (data_size <= free) {
+        // There is free space in the buffer
+        write_buffer(data, data_size);
+    } else {
+        // No free space
+        flush_buffer();
+        if (data_size <= m_buffer_capacity) {
+            // Data fits into the buffer
+            write_buffer(data, data_size);
+        } else {
+            // Doesn't fit
+            write_file(data, data_size);
+        }
+    }
+};
+
+void
+BufferedFileWriter::write_buffer(const char *data, size_t data_size)
+{
+    memcpy(reinterpret_cast<char *>(m_buffer.get()) + m_buffer_size, data,
+           data_size);
+    m_buffer_size += data_size;
+};
+
+void
+BufferedFileWriter::flush_buffer()
+{
+    write_file(m_buffer.get(), m_buffer_size);
+    m_buffer_size = 0;
+};
+
+void
+BufferedFileWriter::write_file(const char *data, size_t data_size)
+{
+    m_file.write(data, data_size);
+    if (!m_file) {
+        throw BufferedFileError("cannot write to output file");
+    }
+};