Put the buffered file code into a namespace

4 files changed, 43 insertions, 38 deletions

diff --git a/src/backup.cpp b/src/backup.cpp
index 4a76be5..238c3ae 100644
--- a/src/backup.cpp
+++ b/src/backup.cpp
@@ -77,7 +77,7 @@ class PagedStreamReader
             m_buffers[0] = std::shared_ptr<char[]>(new char[m_page_size_bytes]);
             m_buffers[1] = std::shared_ptr<char[]>(new char[m_page_size_bytes]);
         } catch (const std::bad_alloc &e) {
-            throw BufferedFileError(
+            throw BufferedFile::Error(
                 "cannot allocate pages for input stream data");
         }
     };
@@ -114,7 +114,7 @@ class PagedStreamReader
         m_istream.read(data, m_page_size_bytes);
 
         if (!m_istream.good() && !m_istream.eof()) {
-            throw BufferedFileError("cannot read from stream");
+            throw BufferedFile::Error("cannot read from stream");
         }
 
         return m_istream.gcount();
@@ -387,13 +387,13 @@ backup(const OptionsBackup &opts)
     std::ifstream in_istream{opts.getInFilePath(),
                              std::ifstream::in | std::ifstream::binary};
     if (!in_istream) {
-        throw BufferedFileError("cannot open input file");
+        throw BufferedFile::Error("cannot open input file");
     }
 
     std::ifstream base_istream{opts.getBaseFilePath(),
                                std::ifstream::in | std::ifstream::binary};
     if (!base_istream) {
-        throw BufferedFileError("cannot open base file");
+        throw BufferedFile::Error("cannot open base file");
     }
 
     // When backing up, the output file is truncated to hold the new data
@@ -401,7 +401,7 @@ backup(const OptionsBackup &opts)
                                                          std::ofstream::trunc |
                                                          std::ofstream::binary};
     if (!out_ostream) {
-        throw BufferedFileError("cannot open output file");
+        throw BufferedFile::Error("cannot open output file");
     }
 
     DiffFinder diff_finder(base_istream, in_istream, opts.getBufferSize(),
diff --git a/src/buffered_file.cpp b/src/buffered_file.cpp
index 8d47eed..5ab5094 100644
--- a/src/buffered_file.cpp
+++ b/src/buffered_file.cpp
@@ -33,20 +33,22 @@
 #include <filesystem>
 #include <fstream>
 
-BufferedFileReader::BufferedFileReader(std::istream &istream,
-                                       size_t buffer_capacity)
+namespace BufferedFile
+{
+
+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 BufferedFileError("cannot allocate buffer for input file data");
+        throw Error("cannot allocate buffer for input file data");
     }
 };
 
 size_t
-BufferedFileReader::read(char *data, size_t data_size)
+Reader::read(char *data, size_t data_size)
 {
     size_t retry_count{0};
     size_t offset{0};
@@ -68,7 +70,7 @@ BufferedFileReader::read(char *data, size_t data_size)
 }
 
 size_t
-BufferedFileReader::tryRead(size_t data_size, char **return_data)
+Reader::tryRead(size_t data_size, char **return_data)
 {
     const size_t size_left{m_buffer_size - m_buffer_offset};
     if (size_left == 0) {
@@ -84,7 +86,7 @@ BufferedFileReader::tryRead(size_t data_size, char **return_data)
 };
 
 size_t
-BufferedFileReader::read_buffer(size_t data_size, char **return_data)
+Reader::read_buffer(size_t data_size, char **return_data)
 {
     *return_data = static_cast<char *>(m_buffer.get()) + m_buffer_offset;
 
@@ -95,38 +97,37 @@ BufferedFileReader::read_buffer(size_t data_size, char **return_data)
 };
 
 void
-BufferedFileReader::refill_buffer()
+Reader::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)
+Reader::read_file(char *data, size_t data_size)
 {
     m_istream.read(data, data_size);
 
     if (!m_istream.good() && !m_istream.eof()) {
-        throw BufferedFileError("cannot read from file");
+        throw Error("cannot read from file");
     }
 
     return m_istream.gcount();
 };
 
-BufferedFileWriter::BufferedFileWriter(std::ostream &ostream,
-                                       size_t buffer_capacity)
+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 BufferedFileError("cannot allocate buffer for output file data");
+        throw Error("cannot allocate buffer for output file data");
     }
 };
-BufferedFileWriter::~BufferedFileWriter() { flush_buffer(); };
+Writer::~Writer() { flush_buffer(); };
 
 void
-BufferedFileWriter::write(const char *data, size_t data_size)
+Writer::write(const char *data, size_t data_size)
 {
     size_t free{m_buffer_capacity - m_buffer_size};
     if (data_size <= free) {
@@ -146,7 +147,7 @@ BufferedFileWriter::write(const char *data, size_t data_size)
 };
 
 void
-BufferedFileWriter::write_buffer(const char *data, size_t data_size)
+Writer::write_buffer(const char *data, size_t data_size)
 {
     memcpy(reinterpret_cast<char *>(m_buffer.get()) + m_buffer_size, data,
            data_size);
@@ -154,17 +155,19 @@ BufferedFileWriter::write_buffer(const char *data, size_t data_size)
 };
 
 void
-BufferedFileWriter::flush_buffer()
+Writer::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)
+Writer::write_file(const char *data, size_t data_size)
 {
     m_ostream.write(data, data_size);
     if (!m_ostream) {
-        throw BufferedFileError("cannot write to output file");
+        throw Error("cannot write to output file");
     }
 };
+
+} // namespace BufferedFile
diff --git a/src/buffered_file.h b/src/buffered_file.h
index 4e5219d..23fa823 100644
--- a/src/buffered_file.h
+++ b/src/buffered_file.h
@@ -32,20 +32,20 @@
 #include <filesystem>
 #include <fstream>
 
-class BufferedFileError : public DiffddError
+namespace BufferedFile
+{
+
+class Error : public DiffddError
 {
   public:
-    explicit BufferedFileError(const std::string &message)
-        : DiffddError(message)
-    {
-    }
+    explicit Error(const std::string &message) : DiffddError(message) {}
 };
 
-class BufferedFileReader
+class Reader
 {
   public:
-    BufferedFileReader(std::istream &istream, size_t buffer_capacity);
-    virtual ~BufferedFileReader() = default;
+    Reader(std::istream &istream, size_t buffer_capacity);
+    virtual ~Reader() = default;
 
     size_t read(char *data, size_t data_size);
     size_t tryRead(size_t data_size, char **return_data);
@@ -62,11 +62,11 @@ class BufferedFileReader
     size_t read_file(char *data, size_t data_size);
 };
 
-class BufferedFileWriter
+class Writer
 {
   public:
-    BufferedFileWriter(std::ostream &ostream, size_t buffer_capacity);
-    virtual ~BufferedFileWriter();
+    Writer(std::ostream &ostream, size_t buffer_capacity);
+    virtual ~Writer();
 
     void write(const char *data, size_t data_size);
 
@@ -80,3 +80,5 @@ class BufferedFileWriter
     void flush_buffer();
     void write_file(const char *data, size_t data_size);
 };
+
+} // namespace BufferedFile
diff --git a/src/format_v2.h b/src/format_v2.h
index 708a252..a455035 100644
--- a/src/format_v2.h
+++ b/src/format_v2.h
@@ -42,7 +42,7 @@ class Writer
 {
   public:
     Writer(std::ostream &ostream, size_t buffer_size)
-        : m_writer{BufferedFileWriter{ostream, buffer_size}} {};
+        : m_writer{BufferedFile::Writer{ostream, buffer_size}} {};
 
     void writeDiffRecord(
         uint64_t offset, size_t size,
@@ -56,7 +56,7 @@ class Writer
     }
 
   private:
-    BufferedFileWriter m_writer;
+    BufferedFile::Writer m_writer;
 
     void writeOffset(uint64_t offset)
     {
@@ -80,7 +80,7 @@ class Reader
 {
   public:
     Reader(std::istream &istream, size_t buffer_size)
-        : m_reader{BufferedFileReader{istream, buffer_size}}, m_eof{false} {};
+        : m_reader{BufferedFile::Reader{istream, buffer_size}}, m_eof{false} {};
 
     bool eof() { return m_eof; };
 
@@ -112,7 +112,7 @@ class Reader
     };
 
   private:
-    BufferedFileReader m_reader;
+    BufferedFile::Reader m_reader;
     bool m_eof;
 };