1 files changed, 173 insertions, 0 deletions
diff --git a/src/buffered_stream.cpp b/src/buffered_stream.cpp
new file mode 100644
index 0000000..371e221
--- /dev/null
+++ b/src/buffered_stream.cpp
@@ -0,0 +1,173 @@
+/* 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_stream.h"
+#include "exception.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstring>
+#include <filesystem>
+#include <fstream>
+
+namespace BufferedStream
+{
+
+Reader::Reader(std::istream &istream, size_t buffer_capacity)
+    : m_istream(istream), m_buffer_offset(0), m_buffer_size(0),
+      m_buffer_capacity(buffer_capacity)
+{
+    try {
+        m_buffer = std::make_unique<char[]>(m_buffer_capacity);
+    } catch (const std::bad_alloc &e) {
+        throw Error("cannot allocate buffer for input stream data");
+    }
+};
+
+size_t
+Reader::read(char *data, size_t data_size)
+{
+    size_t retry_count{0};
+    size_t offset{0};
+
+    while ((data_size > 0) && (retry_count < 2)) {
+        char *d;
+        const size_t r{tryRead(data_size, &d)};
+        if (r == 0) {
+            ++retry_count;
+            continue;
+        }
+
+        memcpy(data + offset, d, r);
+        offset += r;
+        data_size -= r;
+    }
+
+    return offset;
+}
+
+size_t
+Reader::tryRead(size_t data_size, char **return_data)
+{
+    const size_t size_left{m_buffer_size - m_buffer_offset};
+    if (size_left == 0) {
+        refill_buffer();
+        if (m_buffer_size == 0) {
+            return 0;
+        }
+    }
+    // There is at least one byte in the buffer
+    const size_t size_read{read_buffer(data_size, return_data)};
+    assert(size_read > 0);
+    return size_read;
+};
+
+size_t
+Reader::read_buffer(size_t data_size, char **return_data)
+{
+    *return_data = static_cast<char *>(m_buffer.get()) + m_buffer_offset;
+
+    const size_t size_left{m_buffer_size - m_buffer_offset};
+    const size_t size_read{std::min(data_size, size_left)};
+    m_buffer_offset += size_read;
+    return size_read;
+};
+
+void
+Reader::refill_buffer()
+{
+    m_buffer_size = read_stream(m_buffer.get(), m_buffer_capacity);
+    m_buffer_offset = 0;
+};
+
+size_t
+Reader::read_stream(char *data, size_t data_size)
+{
+    m_istream.read(data, data_size);
+
+    if (!m_istream.good() && !m_istream.eof()) {
+        throw Error("cannot read from stream");
+    }
+
+    return m_istream.gcount();
+};
+
+Writer::Writer(std::ostream &ostream, size_t buffer_capacity)
+    : m_ostream(ostream), m_buffer_size(0), m_buffer_capacity(buffer_capacity)
+{
+    try {
+        m_buffer = std::make_unique<char[]>(m_buffer_capacity);
+    } catch (const std::bad_alloc &e) {
+        throw Error("cannot allocate buffer for output stream data");
+    }
+};
+Writer::~Writer() { flush_buffer(); };
+
+void
+Writer::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_stream(data, data_size);
+        }
+    }
+};
+
+void
+Writer::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
+Writer::flush_buffer()
+{
+    write_stream(m_buffer.get(), m_buffer_size);
+    m_buffer_size = 0;
+};
+
+void
+Writer::write_stream(const char *data, size_t data_size)
+{
+    m_ostream.write(data, data_size);
+    if (!m_ostream) {
+        throw Error("cannot write to output stream");
+    }
+};
+
+} // namespace BufferedStream