add MemoryBufferIStream

Author: moritz-h

libsave/include/SatisfactorySave/IO/Archive/IStreamArchive.h

@@ -13,13 +13,12 @@ namespace SatisfactorySave {
 
     class SATISFACTORYSAVE_API IStreamArchive : public Archive {
     public:
-        explicit IStreamArchive(std::vector<char>&& buf)
-            : data_buf_(std::make_unique<std::vector<char>>(std::move(buf))) {
-            istream_ = std::make_unique<MemoryIStream>(std::as_bytes(std::span{data_buf_->data(), data_buf_->size()}));
+        explicit IStreamArchive(std::vector<char>&& buf) {
+            istream_ = std::make_unique<MemoryBufferIStream>(std::move(buf));
         }
 
         explicit IStreamArchive(std::span<const char> buf) {
-            istream_ = std::make_unique<MemoryIStream>(std::as_bytes(buf));
+            istream_ = std::make_unique<MemoryViewIStream>(std::as_bytes(buf));
         }
 
         explicit IStreamArchive(const std::filesystem::path& path) {
@@ -100,7 +99,6 @@ namespace SatisfactorySave {
 
         void validateReadLimit(std::size_t size) override;
 
-        std::unique_ptr<std::vector<char>> data_buf_;
         std::unique_ptr<IStream> istream_;
         std::stack<std::size_t> read_limits_;
         std::stack<std::string> parent_class_info_;

libsave/include/SatisfactorySave/IO/IOStream.h

@@ -41,27 +41,27 @@ namespace SatisfactorySave {
         virtual void write(std::span<const std::byte> in) = 0;
     };
 
-    class SATISFACTORYSAVE_API MemoryIStream : public IStream {
+    class SATISFACTORYSAVE_API MemoryViewIStream : public IStream {
     public:
-        explicit MemoryIStream(std::span<const std::byte> buffer) : buffer_(buffer), pos_(0) {}
+        explicit MemoryViewIStream(std::span<const std::byte> buffer) : buffer_(buffer), pos_(0) {}
 
         [[nodiscard]] pos_type tell() const override {
             return pos_;
         }
 
         void seek(pos_type pos) override {
             if (pos > buffer_.size()) {
-                throw std::out_of_range("MemoryIStream: Seek out of range.");
+                throw std::out_of_range("MemoryViewIStream: Seek out of range.");
             }
             pos_ = pos;
         }
 
         void seek_relative(off_type off) override {
             if (off < 0 && static_cast<pos_type>(-off) > pos_) {
-                throw std::out_of_range("MemoryIStream: Seek out of range.");
+                throw std::out_of_range("MemoryViewIStream: Seek out of range.");
             }
             if (off > 0 && pos_ + off > buffer_.size()) {
-                throw std::out_of_range("MemoryIStream: Seek out of range.");
+                throw std::out_of_range("MemoryViewIStream: Seek out of range.");
             }
             pos_ += off;
         }
@@ -72,17 +72,31 @@ namespace SatisfactorySave {
 
         void read(std::span<std::byte> out) override {
             if (pos_ + out.size() > buffer_.size()) {
-                throw std::runtime_error("MemoryIStream: Not enough data to read.");
+                throw std::runtime_error("MemoryViewIStream: Not enough data to read.");
             }
             std::memcpy(out.data(), buffer_.data() + pos_, out.size());
             pos_ += out.size();
         }
 
-    private:
+    protected:
+        MemoryViewIStream() : pos_(0) {}
+
         std::span<const std::byte> buffer_;
         pos_type pos_;
     };
 
+    class MemoryBufferIStream : public MemoryViewIStream {
+    public:
+        explicit MemoryBufferIStream(std::vector<char>&& buffer)
+            : MemoryViewIStream(),
+              buffer_data_(std::move(buffer)) {
+            buffer_ = std::as_bytes(std::span(buffer_data_));
+        }
+
+    private:
+        std::vector<char> buffer_data_;
+    };
+
     class SATISFACTORYSAVE_API MemoryOStream : public OStream {
     public:
         MemoryOStream() : content_size_(0), pos_(0) {}