Implement archive files (#379)

Author: andiwand

CMakeLists.txt

@@ -72,6 +72,7 @@ set(ODR_SOURCE_FILES
         "src/odr/internal/resource_data.cpp"
 
         "src/odr/internal/cfb/cfb_archive.cpp"
+        "src/odr/internal/cfb/cfb_file.cpp"
         "src/odr/internal/cfb/cfb_impl.cpp"
         "src/odr/internal/cfb/cfb_util.cpp"
 
@@ -164,6 +165,7 @@ set(ODR_SOURCE_FILES
 
         "src/odr/internal/zip/zip_archive.cpp"
         "src/odr/internal/zip/zip_exceptions.cpp"
+        "src/odr/internal/zip/zip_file.cpp"
         "src/odr/internal/zip/zip_util.cpp"
 )
 

src/odr/archive.cpp

@@ -19,6 +19,6 @@ Filesystem Archive::filesystem() const {
           m_impl->filesystem()));
 }
 
-void Archive::save(const std::string &path) const { m_impl->save(path); }
+void Archive::save(std::ostream &out) const { m_impl->save(out); }
 
 } // namespace odr

src/odr/archive.hpp

@@ -20,7 +20,7 @@ class Archive {
 
   [[nodiscard]] Filesystem filesystem() const;
 
-  void save(const std::string &path) const;
+  void save(std::ostream &out) const;
 
 private:
   std::shared_ptr<internal::abstract::Archive> m_impl;

src/odr/internal/abstract/archive.hpp

@@ -16,7 +16,7 @@ class Archive {
 
   [[nodiscard]] virtual std::shared_ptr<Filesystem> filesystem() const = 0;
 
-  virtual void save(const common::Path &path) const = 0;
+  virtual void save(std::ostream &out) const = 0;
 };
 
 } // namespace odr::internal::abstract

src/odr/internal/cfb/cfb_archive.cpp

@@ -1,6 +1,8 @@
 #include <odr/internal/cfb/cfb_archive.hpp>
 
+#include <odr/exceptions.hpp>
 #include <odr/internal/cfb/cfb_util.hpp>
+#include <odr/internal/common/filesystem.hpp>
 #include <odr/internal/util/string_util.hpp>
 
 namespace odr::internal::abstract {
@@ -13,192 +15,23 @@ class MemoryFile;
 
 namespace odr::internal::cfb {
 
-ReadonlyCfbArchive::Entry::Entry(const ReadonlyCfbArchive &parent,
-                                 const impl::CompoundFileEntry &entry)
-    : m_parent{&parent}, m_entry{&entry}, m_path{"/"} {}
+CfbArchive::CfbArchive(std::shared_ptr<util::Archive> archive)
+    : m_cfb{std::move(archive)} {}
 
-ReadonlyCfbArchive::Entry::Entry(const ReadonlyCfbArchive &parent,
-                                 const impl::CompoundFileEntry &entry,
-                                 const common::Path &parent_path)
-    : m_parent{&parent}, m_entry{&entry}, m_path{parent_path.join(name())} {}
+std::shared_ptr<abstract::Filesystem> CfbArchive::filesystem() const {
+  auto filesystem = std::make_shared<common::VirtualFilesystem>();
 
-bool ReadonlyCfbArchive::Entry::operator==(const Entry &other) const {
-  return m_entry == other.m_entry;
-}
-
-bool ReadonlyCfbArchive::Entry::operator!=(const Entry &other) const {
-  return m_entry != other.m_entry;
-}
-
-bool ReadonlyCfbArchive::Entry::is_file() const { return m_entry->is_stream(); }
-
-bool ReadonlyCfbArchive::Entry::is_directory() const {
-  return !m_entry->is_stream();
-}
-
-common::Path ReadonlyCfbArchive::Entry::path() const { return m_path; }
-
-std::unique_ptr<abstract::File> ReadonlyCfbArchive::Entry::file() const {
-  if (!is_file()) {
-    return {};
-  }
-  return std::make_unique<util::FileInCfb>(m_parent->m_cfb, *m_entry);
-}
-
-std::string ReadonlyCfbArchive::Entry::name() const {
-  return odr::internal::util::string::c16str_to_string(
-      reinterpret_cast<const char16_t *>(m_entry->name), m_entry->name_len - 2);
-}
-
-std::optional<ReadonlyCfbArchive::Entry>
-ReadonlyCfbArchive::Entry::left() const {
-  auto left = m_parent->m_cfb->cfb().get_entry(m_entry->left_sibling_id);
-  if (left == nullptr) {
-    return {};
-  }
-  return Entry(*m_parent, *left, m_path.parent());
-}
-
-std::optional<ReadonlyCfbArchive::Entry>
-ReadonlyCfbArchive::Entry::right() const {
-  auto right = m_parent->m_cfb->cfb().get_entry(m_entry->right_sibling_id);
-  if (right == nullptr) {
-    return {};
-  }
-  return Entry(*m_parent, *right, m_path.parent());
-}
-
-std::optional<ReadonlyCfbArchive::Entry>
-ReadonlyCfbArchive::Entry::child() const {
-  auto child = m_parent->m_cfb->cfb().get_entry(m_entry->child_id);
-  if (child == nullptr) {
-    return {};
-  }
-  return Entry(*m_parent, *child, m_path);
-}
-
-ReadonlyCfbArchive::Iterator::Iterator() = default;
-
-ReadonlyCfbArchive::Iterator::Iterator(const ReadonlyCfbArchive &parent,
-                                       const impl::CompoundFileEntry &entry)
-    : m_entry{Entry(parent, entry)} {
-  dig_left_();
-}
-
-ReadonlyCfbArchive::Iterator::Iterator(const ReadonlyCfbArchive &parent,
-                                       const impl::CompoundFileEntry &entry,
-                                       const common::Path &parent_path)
-    : m_entry{Entry(parent, entry, parent_path)} {
-  dig_left_();
-}
-
-void ReadonlyCfbArchive::Iterator::dig_left_() {
-  if (!m_entry) {
-    return;
-  }
-
-  while (true) {
-    auto left = m_entry->left();
-    if (!left) {
-      break;
+  for (const auto &e : *m_cfb) {
+    if (e.is_directory()) {
+      filesystem->create_directory(e.path());
+    } else if (e.is_file()) {
+      filesystem->copy(e.file(), e.path());
     }
-    m_ancestors.push_back(*m_entry);
-    m_entry = left;
-  }
-}
-
-void ReadonlyCfbArchive::Iterator::next_() {
-  if (!m_entry) {
-    return;
   }
 
-  auto child = m_entry->child();
-  if (child) {
-    m_directories.push_back(*m_entry);
-    m_entry = child;
-    dig_left_();
-    return;
-  }
-
-  next_flat_();
-}
-
-void ReadonlyCfbArchive::Iterator::next_flat_() {
-  if (!m_entry) {
-    return;
-  }
-
-  auto right = m_entry->right();
-  if (right) {
-    m_entry = right;
-    dig_left_();
-    return;
-  }
-
-  if (!m_ancestors.empty()) {
-    m_entry = m_ancestors.back();
-    m_ancestors.pop_back();
-    return;
-  }
-
-  if (!m_directories.empty()) {
-    m_entry = m_directories.back();
-    m_directories.pop_back();
-    next_flat_();
-    return;
-  }
-
-  m_entry = {};
-}
-
-ReadonlyCfbArchive::Iterator::reference
-ReadonlyCfbArchive::Iterator::operator*() const {
-  return *m_entry;
-}
-
-ReadonlyCfbArchive::Iterator::pointer
-ReadonlyCfbArchive::Iterator::operator->() const {
-  return &*m_entry;
+  return filesystem;
 }
 
-bool ReadonlyCfbArchive::Iterator::operator==(const Iterator &other) const {
-  return m_entry == other.m_entry;
-}
-
-bool ReadonlyCfbArchive::Iterator::operator!=(const Iterator &other) const {
-  return m_entry != other.m_entry;
-}
-
-ReadonlyCfbArchive::Iterator &ReadonlyCfbArchive::Iterator::operator++() {
-  next_();
-  return *this;
-}
-
-ReadonlyCfbArchive::Iterator ReadonlyCfbArchive::Iterator::operator++(int) {
-  Iterator tmp = *this;
-  ++(*this);
-  return tmp;
-}
-
-ReadonlyCfbArchive::ReadonlyCfbArchive(
-    const std::shared_ptr<common::MemoryFile> &file)
-    : m_cfb{std::make_shared<util::Archive>(file)} {}
-
-ReadonlyCfbArchive::Iterator ReadonlyCfbArchive::begin() const {
-  return {*this, *m_cfb->cfb().get_root_entry()};
-}
-
-ReadonlyCfbArchive::Iterator ReadonlyCfbArchive::end() const { return {}; }
-
-ReadonlyCfbArchive::Iterator
-ReadonlyCfbArchive::find(const common::Path &path) const {
-  for (auto it = begin(); it != end(); ++it) {
-    if (it->path() == path) {
-      return it;
-    }
-  }
-
-  return end();
-}
+void CfbArchive::save(std::ostream &out) const { throw UnsupportedOperation(); }
 
 } // namespace odr::internal::cfb

src/odr/internal/cfb/cfb_archive.hpp

@@ -1,7 +1,7 @@
 #ifndef ODR_INTERNAL_CFB_ARCHIVE_HPP
 #define ODR_INTERNAL_CFB_ARCHIVE_HPP
 
-#include <odr/internal/cfb/cfb_impl.hpp>
+#include <odr/internal/abstract/archive.hpp>
 #include <odr/internal/common/file.hpp>
 #include <odr/internal/common/path.hpp>
 
@@ -11,6 +11,11 @@
 #include <string>
 #include <vector>
 
+namespace odr {
+enum class FileType;
+struct FileMeta;
+} // namespace odr
+
 namespace odr::internal::abstract {
 class File;
 } // namespace odr::internal::abstract
@@ -19,89 +24,19 @@ namespace odr::internal::cfb::impl {
 struct CompoundFileEntry;
 } // namespace odr::internal::cfb::impl
 
-namespace odr::internal::common {
-class MemoryFile;
-} // namespace odr::internal::common
-
 namespace odr::internal::cfb::util {
 class Archive;
 }
 
 namespace odr::internal::cfb {
 
-class ReadonlyCfbArchive final {
+class CfbArchive final : public abstract::Archive {
 public:
-  explicit ReadonlyCfbArchive(const std::shared_ptr<common::MemoryFile> &file);
-
-  class Iterator;
-
-  [[nodiscard]] Iterator begin() const;
-  [[nodiscard]] Iterator end() const;
-
-  [[nodiscard]] Iterator find(const common::Path &path) const;
-
-  class Entry {
-  public:
-    Entry(const ReadonlyCfbArchive &parent,
-          const impl::CompoundFileEntry &entry);
-    Entry(const ReadonlyCfbArchive &parent,
-          const impl::CompoundFileEntry &entry,
-          const common::Path &parent_path);
-
-    bool operator==(const Entry &other) const;
-    bool operator!=(const Entry &other) const;
-
-    [[nodiscard]] bool is_file() const;
-    [[nodiscard]] bool is_directory() const;
-    [[nodiscard]] common::Path path() const;
-    [[nodiscard]] std::unique_ptr<abstract::File> file() const;
-
-    [[nodiscard]] std::string name() const;
-    [[nodiscard]] std::optional<Entry> left() const;
-    [[nodiscard]] std::optional<Entry> right() const;
-    [[nodiscard]] std::optional<Entry> child() const;
-
-  private:
-    const ReadonlyCfbArchive *m_parent;
-    const impl::CompoundFileEntry *m_entry;
-    common::Path m_path;
-
-    friend Iterator;
-  };
-
-  class Iterator {
-  public:
-    using iterator_category = std::forward_iterator_tag;
-    using difference_type = std::ptrdiff_t;
-    using value_type = Entry;
-    using pointer = const Entry *;
-    using reference = const Entry &;
-
-    Iterator();
-    Iterator(const ReadonlyCfbArchive &parent,
-             const impl::CompoundFileEntry &entry);
-    Iterator(const ReadonlyCfbArchive &parent,
-             const impl::CompoundFileEntry &entry,
-             const common::Path &parent_path);
-
-    reference operator*() const;
-    pointer operator->() const;
-
-    bool operator==(const Iterator &other) const;
-    bool operator!=(const Iterator &other) const;
-
-    Iterator &operator++();
-    Iterator operator++(int);
+  explicit CfbArchive(std::shared_ptr<util::Archive> archive);
 
-  private:
-    std::optional<Entry> m_entry;
-    std::vector<Entry> m_ancestors;
-    std::vector<Entry> m_directories;
+  [[nodiscard]] std::shared_ptr<abstract::Filesystem> filesystem() const final;
 
-    void dig_left_();
-    void next_();
-    void next_flat_();
-  };
+  void save(std::ostream &out) const final;
 
 private:
   std::shared_ptr<util::Archive> m_cfb;

src/odr/internal/cfb/cfb_file.cpp

@@ -0,0 +1,29 @@
+#include <odr/internal/cfb/cfb_file.hpp>
+
+#include <odr/internal/cfb/cfb_archive.hpp>
+#include <odr/internal/cfb/cfb_util.hpp>
+
+namespace odr::internal::cfb {
+
+CfbFile::CfbFile(const std::shared_ptr<common::MemoryFile> &file)
+    : m_cfb{std::make_shared<util::Archive>(file)} {}
+
+std::shared_ptr<abstract::File> CfbFile::file() const noexcept {
+  return m_cfb->file();
+}
+
+FileType CfbFile::file_type() const noexcept {
+  return FileType::compound_file_binary_format;
+}
+
+FileMeta CfbFile::file_meta() const noexcept {
+  FileMeta meta;
+  meta.type = file_type();
+  return meta;
+}
+
+std::shared_ptr<abstract::Archive> CfbFile::archive() const {
+  return std::make_shared<CfbArchive>(m_cfb);
+}
+
+} // namespace odr::internal::cfb