use custom io streams for 64bit memory support

Author: moritz-h

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

@@ -1,19 +1,30 @@
 #pragma once
 
-#include <fstream>
 #include <memory>
 #include <stack>
 #include <string>
 #include <vector>
 
 #include "../../Utils/StackUtils.h"
+#include "../IOStream.h"
 #include "Archive.h"
 
 namespace SatisfactorySave {
 
     class SATISFACTORYSAVE_API IStreamArchive : public Archive {
     public:
-        explicit IStreamArchive(std::unique_ptr<std::istream> istream) : istream_(std::move(istream)) {}
+        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::span<const char> buf) {
+            istream_ = std::make_unique<MemoryIStream>(std::as_bytes(buf));
+        }
+
+        explicit IStreamArchive(const std::filesystem::path& path) {
+            istream_ = std::make_unique<FileIStream>(path);
+        }
 
         template<typename T>
         inline T read() {
@@ -53,15 +64,15 @@ namespace SatisfactorySave {
         }
 
         std::size_t tell() override {
-            return static_cast<std::size_t>(istream_->tellg());
+            return istream_->tell();
         }
 
         void seek(std::size_t pos) override {
-            istream_->seekg(static_cast<std::istream::pos_type>(pos));
+            istream_->seek(pos);
         }
 
-        std::istream& rawStream() {
-            return *istream_;
+        [[nodiscard]] std::size_t size() const {
+            return istream_->size();
         }
 
         inline auto pushReadLimit(std::size_t size) {
@@ -81,8 +92,6 @@ namespace SatisfactorySave {
         }
 
     protected:
-        IStreamArchive() = default;
-
         void serialize(void* data, std::size_t size) override;
 
         void serializeString(std::string& s) override;
@@ -91,32 +100,9 @@ namespace SatisfactorySave {
 
         void validateReadLimit(std::size_t size) override;
 
-        std::unique_ptr<std::istream> istream_;
+        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_;
     };
-
-    class SATISFACTORYSAVE_API IFStreamArchive : public IStreamArchive {
-    public:
-        explicit IFStreamArchive(const std::filesystem::path& filepath) {
-            auto file = std::make_unique<std::ifstream>(filepath, std::ios::binary);
-            if (!file->is_open()) {
-                throw std::runtime_error("Cannot read file: " + filepath.string());
-            }
-
-            // File size
-            file->seekg(0, std::ios::end);
-            filesize_ = file->tellg();
-            file->seekg(0, std::ios::beg);
-
-            istream_ = std::move(file);
-        }
-
-        [[nodiscard]] std::size_t size() const {
-            return filesize_;
-        }
-
-    protected:
-        std::size_t filesize_ = 0;
-    };
 } // namespace SatisfactorySave

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

@@ -1,16 +1,21 @@
 #pragma once
 
-#include <fstream>
 #include <memory>
 
-#include "../MemoryStreams.h"
+#include "../IOStream.h"
 #include "Archive.h"
 
 namespace SatisfactorySave {
 
     class SATISFACTORYSAVE_API OStreamArchive : public Archive {
     public:
-        explicit OStreamArchive(std::unique_ptr<std::ostream> ostream) : ostream_(std::move(ostream)) {}
+        explicit OStreamArchive() : is_memory_stream_(true) {
+            ostream_ = std::make_unique<MemoryOStream>();
+        }
+
+        explicit OStreamArchive(const std::filesystem::path& filepath) : is_memory_stream_(false) {
+            ostream_ = std::make_unique<FileOStream>(filepath);
+        }
 
         template<typename T>
         void write(T value) {
@@ -30,49 +35,28 @@ namespace SatisfactorySave {
         }
 
         std::size_t tell() override {
-            return static_cast<std::size_t>(ostream_->tellp());
+            return ostream_->tell();
         }
 
         void seek(std::size_t pos) override {
-            ostream_->seekp(static_cast<std::istream::pos_type>(pos));
+            ostream_->seek(pos);
         }
 
-        std::ostream& rawStream() {
-            return *ostream_;
+        [[nodiscard]] std::span<const std::byte> buffer_view() const {
+            if (is_memory_stream_) {
+                return dynamic_cast<MemoryOStream&>(*ostream_).buffer_view();
+            }
+            throw std::runtime_error("Not a memory stream! Cannot get buffer view!");
         }
 
     protected:
-        OStreamArchive() = default;
-
         void serialize(void* data, std::size_t size) override;
 
         void serializeString(std::string& s) override;
 
         void serializeName(FName& n) override;
 
-        std::unique_ptr<std::ostream> ostream_;
-    };
-
-    class SATISFACTORYSAVE_API OFStreamArchive : public OStreamArchive {
-    public:
-        explicit OFStreamArchive(const std::filesystem::path& filepath) {
-            auto file = std::make_unique<std::ofstream>(filepath, std::ios::binary);
-            if (!file->is_open()) {
-                throw std::runtime_error("Cannot write file!");
-            }
-
-            ostream_ = std::move(file);
-        }
-    };
-
-    class SATISFACTORYSAVE_API OMemStreamArchive : public OStreamArchive {
-    public:
-        explicit OMemStreamArchive() {
-            ostream_ = std::make_unique<MemOStream>();
-        }
-
-        [[nodiscard]] const std::vector<char>& data() const {
-            return dynamic_cast<MemOStream&>(*ostream_).data();
-        }
+        std::unique_ptr<OStream> ostream_;
+        bool is_memory_stream_;
     };
 } // namespace SatisfactorySave