Break out tpp load and save methods

1 files changed, 31 insertions, 76 deletions

diff --git a/src/monitor-gui.cc b/src/monitor-gui.cc
index 6805814..b02c4de 100644
--- a/src/monitor-gui.cc
+++ b/src/monitor-gui.cc
@@ -39,6 +39,7 @@
 #include "looper.hh"
 #include "monitor.hh"
 #include "observers.hh"
+#include "packages.hh"
 #include "protocols.hh"
 #include "proxy.hh"
 #include "resolver.hh"
@@ -682,6 +683,24 @@ private:
     }
   };
 
+  class PackagesReaderDelegate : public PackagesReader::Delegate {
+  public:
+    PackagesReaderDelegate(PackageList* packages)
+      : packages_(packages) {
+    }
+
+    void package(Package const& package) override {
+      packages_->package(package);
+    }
+
+    void data(uint32_t id, char const* data, size_t size, bool last) override {
+      packages_->package_data(id, data, size, last);
+    }
+
+  private:
+    PackageList* const packages_;
+  };
+
 public:
   MonitorGui()
     : packages_(new PackageList()),
@@ -1593,65 +1612,18 @@ private:
       show_error("Unable to open " + file + " for reading");
       return false;
     }
-    uint8_t header[8];
-    in.read(reinterpret_cast<char*>(header), 8);
-    if (!in.good() || memcmp(header, "TPP", 3) || header[3] != 1) {
-      show_error("Not a valid package file: " +file);
+    auto delegate = std::unique_ptr<PackagesReaderDelegate>(
+        new PackagesReaderDelegate(packages));
+    switch (PackagesReader::read(in, delegate.get())) {
+    case PackagesReader::INVALID:
+      show_error("Not a valid package file: " + file);
       return false;
-    }
-    uint32_t count = read_u32(header + 4);
-    bool good = true;
-    while (count--) {
-      good = false;
-      in.read(reinterpret_cast<char*>(header), 8);
-      if (!in.good()) break;
-      size_t size = read_u64(header);
-      if (size == 0) break;
-      uint8_t buf[8192];
-      size_t avail = std::min(size, sizeof(buf));
-      in.read(reinterpret_cast<char*>(buf), avail);
-      if (!in.good()) break;
-      ::Package pkg;
-      auto pkg_size = read_package(&pkg, buf, avail);
-      if (pkg_size == 0) {
-        if (avail == size) break;
-        size_t need = std::min(static_cast<size_t>(1024) * 1024, size);
-        std::unique_ptr<uint8_t[]> mem(new uint8_t[need]);
-        memcpy(mem.get(), buf, avail);
-        in.read(reinterpret_cast<char*>(mem.get()) + avail, need - avail);
-        if (!in.good()) break;
-        pkg_size = read_package(&pkg, mem.get(), need);
-        if (pkg_size == 0) break;
-        packages->package(pkg);
-        packages->package_data(pkg.id, reinterpret_cast<char*>(mem.get())
-                               + pkg_size, need - pkg_size, need == size);
-        size -= need;
-      } else {
-        packages->package(pkg);
-        packages->package_data(pkg.id, reinterpret_cast<char*>(buf) + pkg_size,
-                               avail - pkg_size, avail == size);
-        size -= avail;
-      }
-      while (size) {
-        avail = std::min(sizeof(buf), size);
-        in.read(reinterpret_cast<char*>(buf), avail);
-        if (!in.good()) break;
-        packages->package_data(pkg.id, reinterpret_cast<char*>(buf), avail,
-                               avail == size);
-        size -= avail;
-      }
-      if (size) break;
-      good = true;
-    }
-    if (good) {
-      in.read(reinterpret_cast<char*>(header), 8);
-      if (!in.good() || read_u64(header) != 0) good = false;
-    }
-    if (!good) {
+    case PackagesReader::IO_ERROR:
       show_error("Error reading from " + file);
       return false;
+    case PackagesReader::GOOD:
+      return true;
     }
-    return true;
   }
 
   bool save(PackageList const* packages, std::string const& file) {
@@ -1661,30 +1633,13 @@ private:
       show_error("Unable to open " + file + " for writing");
       return false;
     }
-    uint8_t header[8];
-    memcpy(header, "TPP", 3);
-    header[3] = 0x1;  // Version
-    write_u32(header + 4, packages->rows());  // Count
-    out.write(reinterpret_cast<char*>(header), 8);
+    auto writer = std::unique_ptr<PackagesWriter>(
+        PackagesWriter::create(packages->rows(), &out));
     for (size_t i = 0; i < packages->rows(); ++i) {
       auto const& pkg = packages->package(i);
-      uint8_t buf[8192];
-      std::unique_ptr<uint8_t[]> backup;
-      uint8_t* ptr = buf;
-      size_t need = write_package(pkg.pkg, buf, sizeof(buf));
-      if (need > sizeof(buf)) {
-        backup.reset(new uint8_t[need]);
-        ptr = backup.get();
-        write_package(pkg.pkg, ptr, need);
-      }
-      write_u64(header, need + pkg.data.size());
-      out.write(reinterpret_cast<char*>(header), 8);
-      out.write(reinterpret_cast<char*>(ptr), need);
-      backup.reset();
-      out.write(pkg.data.data(), pkg.data.size());
+      writer->write(pkg.pkg, pkg.data);
     }
-    write_u64(header, 0);  // EOF
-    out.write(reinterpret_cast<char*>(header), 8);
+    writer.reset();
     if (!out.good()) {
       show_error("Error writing " + file);
       return false;