remove internal::common namespace

src/odr/document.cpp

@@ -26,12 +26,12 @@ bool Document::is_savable(const bool encrypted) const noexcept {
 }
 
 void Document::save(const std::string &path) const {
-  m_impl->save(internal::common::Path(path));
+  m_impl->save(internal::Path(path));
 }
 
 void Document::save(const std::string &path,
                     const std::string &password) const {
-  m_impl->save(internal::common::Path(path), password.c_str());
+  m_impl->save(internal::Path(path), password.c_str());
 }
 
 FileType Document::file_type() const noexcept { return m_impl->file_type(); }

src/odr/file.cpp

@@ -33,7 +33,7 @@ File::File(std::shared_ptr<internal::abstract::File> impl)
     : m_impl{std::move(impl)} {}
 
 File::File(const std::string &path)
-    : m_impl{std::make_shared<internal::common::DiskFile>(path)} {}
+    : m_impl{std::make_shared<internal::DiskFile>(path)} {}
 
 FileLocation File::location() const noexcept { return m_impl->location(); }
 
@@ -63,7 +63,7 @@ std::shared_ptr<internal::abstract::File> File::impl() const { return m_impl; }
 std::vector<FileType> DecodedFile::list_file_types(const std::string &path,
                                                    Logger &logger) {
   return internal::open_strategy::list_file_types(
-      std::make_shared<internal::common::DiskFile>(path), logger);
+      std::make_shared<internal::DiskFile>(path), logger);
 }
 
 std::vector<DecoderEngine> DecodedFile::list_decoder_engines(FileType as) {
@@ -86,17 +86,16 @@ DecodedFile::DecodedFile(const File &file, FileType as, Logger &logger)
 
 DecodedFile::DecodedFile(const std::string &path, Logger &logger)
     : DecodedFile(internal::open_strategy::open_file(
-          std::make_shared<internal::common::DiskFile>(path), logger)) {}
+          std::make_shared<internal::DiskFile>(path), logger)) {}
 
 DecodedFile::DecodedFile(const std::string &path, FileType as, Logger &logger)
     : DecodedFile(internal::open_strategy::open_file(
-          std::make_shared<internal::common::DiskFile>(path), as, logger)) {}
+          std::make_shared<internal::DiskFile>(path), as, logger)) {}
 
 DecodedFile::DecodedFile(const std::string &path,
                          const DecodePreference &preference, Logger &logger)
     : DecodedFile(internal::open_strategy::open_file(
-          std::make_shared<internal::common::DiskFile>(path), preference,
-          logger)) {}
+          std::make_shared<internal::DiskFile>(path), preference, logger)) {}
 
 File DecodedFile::file() const { return File(m_impl->file()); }
 
@@ -230,7 +229,7 @@ DocumentFile::DocumentFile(
 
 DocumentFile::DocumentFile(const std::string &path, Logger &logger)
     : DocumentFile(internal::open_strategy::open_document_file(
-          std::make_shared<internal::common::DiskFile>(path), logger)) {}
+          std::make_shared<internal::DiskFile>(path), logger)) {}
 
 DocumentType DocumentFile::document_type() const {
   return m_impl->document_type();

src/odr/filesystem.cpp

@@ -20,42 +20,49 @@ FileWalker::FileWalker(FileWalker &&other) noexcept = default;
 FileWalker::~FileWalker() = default;
 
 FileWalker &FileWalker::operator=(const odr::FileWalker &other) {
+  if (this == &other) {
+    return *this;
+  }
   m_impl = other.m_impl->clone();
   return *this;
 }
 
 FileWalker &FileWalker::operator=(odr::FileWalker &&) noexcept = default;
 
-FileWalker::operator bool() const { return m_impl.operator bool(); }
+FileWalker::operator bool() const { return m_impl != nullptr; }
 
-bool FileWalker::end() const { return m_impl ? m_impl->end() : true; }
+bool FileWalker::end() const { return m_impl == nullptr || m_impl->end(); }
 
-std::uint32_t FileWalker::depth() const { return m_impl ? m_impl->depth() : 0; }
+std::uint32_t FileWalker::depth() const {
+  return m_impl != nullptr ? m_impl->depth() : 0;
+}
 
 std::string FileWalker::path() const {
-  return m_impl ? m_impl->path().string() : std::string("");
+  return m_impl != nullptr ? m_impl->path().string() : std::string("");
 }
 
-bool FileWalker::is_file() const { return m_impl ? m_impl->is_file() : false; }
+bool FileWalker::is_file() const {
+  return m_impl != nullptr && m_impl->is_file();
+}
 
 bool FileWalker::is_directory() const {
-  return m_impl ? m_impl->is_directory() : false;
+  return m_impl != nullptr && m_impl->is_directory();
 }
 
 void FileWalker::pop() {
-  if (m_impl) {
+  if (m_impl != nullptr) {
     m_impl->pop();
   }
 }
 
 void FileWalker::next() {
-  if (m_impl) {
+  if (m_impl != nullptr) {
     m_impl->next();
   }
 }
 
 void FileWalker::flat_next() {
-  if (m_impl) {
+  if (m_impl != nullptr) {
     m_impl->flat_next();
   }
 }
@@ -64,27 +71,28 @@ Filesystem::Filesystem(
     std::shared_ptr<internal::abstract::ReadableFilesystem> impl)
     : m_impl{std::move(impl)} {}
 
-Filesystem::operator bool() const { return m_impl.operator bool(); }
+Filesystem::operator bool() const { return m_impl != nullptr; }
 
 bool Filesystem::exists(const std::string &path) const {
-  return m_impl ? m_impl->exists(internal::common::Path(path)) : false;
+  return m_impl != nullptr && m_impl->exists(internal::Path(path));
 }
 
 bool Filesystem::is_file(const std::string &path) const {
-  return m_impl ? m_impl->is_file(internal::common::Path(path)) : false;
+  return m_impl != nullptr && m_impl->is_file(internal::Path(path));
 }
 
 bool Filesystem::is_directory(const std::string &path) const {
-  return m_impl ? m_impl->is_directory(internal::common::Path(path)) : false;
+  return m_impl != nullptr && m_impl->is_directory(internal::Path(path));
 }
 
 FileWalker Filesystem::file_walker(const std::string &path) const {
-  return m_impl ? FileWalker(m_impl->file_walker(internal::common::Path(path)))
-                : FileWalker();
+  return m_impl != nullptr
+             ? FileWalker(m_impl->file_walker(internal::Path(path)))
+             : FileWalker();
 }
 
 File Filesystem::open(const std::string &path) const {
-  return m_impl ? File(m_impl->open(internal::common::Path(path))) : File();
+  return m_impl != nullptr ? File(m_impl->open(internal::Path(path))) : File();
 }
 
 } // namespace odr

src/odr/html.cpp

@@ -41,8 +41,8 @@ void bring_offline(const HtmlResources &resources,
         resource.is_external() || !resource.is_accessible()) {
       continue;
     }
-    auto path = odr::internal::common::Path(output_path)
-                    .join(odr::internal::common::Path(*location));
+    auto path =
+        odr::internal::Path(output_path).join(odr::internal::Path(*location));
 
     std::filesystem::create_directories(path.parent());
     std::ofstream ostream = internal::util::file::create(path.string());
@@ -116,8 +116,8 @@ Html HtmlService::bring_offline(const std::string &output_path,
   HtmlResources resources;
 
   for (const auto &view : views) {
-    auto path = odr::internal::common::Path(output_path)
-                    .join(odr::internal::common::Path(view.path()));
+    auto path =
+        odr::internal::Path(output_path).join(odr::internal::Path(view.path()));
 
     std::filesystem::create_directories(path.parent());
     std::ofstream ostream = internal::util::file::create(path.string());
@@ -166,8 +166,8 @@ HtmlResources HtmlView::write_html(std::ostream &out) const {
 Html HtmlView::bring_offline(const std::string &output_path) const {
   HtmlResources resources;
 
-  auto path = odr::internal::common::Path(output_path)
-                  .join(odr::internal::common::Path(this->path()));
+  auto path =
+      odr::internal::Path(output_path).join(odr::internal::Path(this->path()));
 
   {
     std::filesystem::create_directories(path.parent());
@@ -249,10 +249,10 @@ HtmlResourceLocator html::standard_resource_locator() {
     }
 
     if (resource.is_shipped()) {
-      auto resource_path = common::Path(config.resource_path)
-                               .join(common::Path(resource.path()));
+      auto resource_path =
+          Path(config.resource_path).join(Path(resource.path()));
       if (config.relative_resource_paths && config.output_path.has_value()) {
-        resource_path = resource_path.rebase(common::Path(*config.output_path));
+        resource_path = resource_path.rebase(Path(*config.output_path));
       }
       return resource_path.string();
     }

src/odr/internal/abstract/archive.hpp

@@ -2,10 +2,6 @@
 
 #include <memory>
 
-namespace odr::internal::common {
-class Path;
-} // namespace odr::internal::common
-
 namespace odr::internal::abstract {
 class Filesystem;
 

src/odr/internal/abstract/document.hpp

@@ -10,9 +10,9 @@ enum class FileType;
 enum class DocumentType;
 } // namespace odr
 
-namespace odr::internal::common {
+namespace odr::internal {
 class Path;
-} // namespace odr::internal::common
+} // namespace odr::internal
 
 namespace odr::internal::abstract {
 class ReadableFilesystem;
@@ -30,11 +30,11 @@ class Document {
   [[nodiscard]] virtual bool is_savable(bool encrypted) const noexcept = 0;
 
   /// \param path the destination path.
-  virtual void save(const common::Path &path) const = 0;
+  virtual void save(const Path &path) const = 0;
 
   /// \param path the destination path.
   /// \param password the encryption password.
-  virtual void save(const common::Path &path, const char *password) const = 0;
+  virtual void save(const Path &path, const char *password) const = 0;
 
   /// \return the type of the document.
   [[nodiscard]] virtual FileType file_type() const noexcept = 0;

src/odr/internal/abstract/file.hpp

@@ -6,7 +6,7 @@
 #include <memory>
 #include <string>
 
-namespace odr::internal::common {
+namespace odr::internal {
 class Path;
 }
 
@@ -22,7 +22,7 @@ class File {
   [[nodiscard]] virtual FileLocation location() const noexcept = 0;
   [[nodiscard]] virtual std::size_t size() const = 0;
 
-  [[nodiscard]] virtual std::optional<common::Path> disk_path() const = 0;
+  [[nodiscard]] virtual std::optional<Path> disk_path() const = 0;
   [[nodiscard]] virtual const char *memory_data() const = 0;
 
   [[nodiscard]] virtual std::unique_ptr<std::istream> stream() const = 0;

src/odr/internal/abstract/filesystem.hpp

@@ -3,9 +3,9 @@
 #include <cstdint>
 #include <memory>
 
-namespace odr::internal::common {
+namespace odr::internal {
 class Path;
-} // namespace odr::internal::common
+} // namespace odr::internal
 
 namespace odr::internal::abstract {
 class File;
@@ -20,7 +20,7 @@ class FileWalker {
   [[nodiscard]] virtual bool end() const = 0;
   [[nodiscard]] virtual std::uint32_t depth() const = 0;
   // TODO by reference?
-  [[nodiscard]] virtual common::Path path() const = 0;
+  [[nodiscard]] virtual Path path() const = 0;
   [[nodiscard]] virtual bool is_file() const = 0;
   [[nodiscard]] virtual bool is_directory() const = 0;
 
@@ -33,32 +33,31 @@ class ReadableFilesystem {
 public:
   virtual ~ReadableFilesystem() = default;
 
-  [[nodiscard]] virtual bool exists(const common::Path &path) const = 0;
-  [[nodiscard]] virtual bool is_file(const common::Path &path) const = 0;
-  [[nodiscard]] virtual bool is_directory(const common::Path &path) const = 0;
+  [[nodiscard]] virtual bool exists(const Path &path) const = 0;
+  [[nodiscard]] virtual bool is_file(const Path &path) const = 0;
+  [[nodiscard]] virtual bool is_directory(const Path &path) const = 0;
 
   [[nodiscard]] virtual std::unique_ptr<FileWalker>
-  file_walker(const common::Path &path) const = 0;
+  file_walker(const Path &path) const = 0;
 
   [[nodiscard]] virtual std::shared_ptr<abstract::File>
-  open(const common::Path &path) const = 0;
+  open(const Path &path) const = 0;
 };
 
 class WriteableFilesystem {
 public:
   virtual ~WriteableFilesystem() = default;
 
-  virtual std::unique_ptr<std::ostream>
-  create_file(const common::Path &path) = 0;
-  virtual bool create_directory(const common::Path &path) = 0;
+  virtual std::unique_ptr<std::ostream> create_file(const Path &path) = 0;
+  virtual bool create_directory(const Path &path) = 0;
 
-  virtual bool remove(const common::Path &path) = 0;
-  virtual bool copy(const common::Path &from, const common::Path &to) = 0;
+  virtual bool remove(const Path &path) = 0;
+  virtual bool copy(const Path &from, const Path &to) = 0;
   virtual std::shared_ptr<abstract::File> copy(const abstract::File &from,
-                                               const common::Path &to) = 0;
+                                               const Path &to) = 0;
   virtual std::shared_ptr<abstract::File>
-  copy(std::shared_ptr<abstract::File> from, const common::Path &to) = 0;
-  virtual bool move(const common::Path &from, const common::Path &to) = 0;
+  copy(std::shared_ptr<abstract::File> from, const Path &to) = 0;
+  virtual bool move(const Path &from, const Path &to) = 0;
 };
 
 class Filesystem : public ReadableFilesystem, public WriteableFilesystem {};

src/odr/internal/cfb/cfb_archive.cpp

@@ -19,7 +19,7 @@ CfbArchive::CfbArchive(std::shared_ptr<util::Archive> archive)
     : m_cfb{std::move(archive)} {}
 
 std::shared_ptr<abstract::Filesystem> CfbArchive::as_filesystem() const {
-  auto filesystem = std::make_shared<common::VirtualFilesystem>();
+  auto filesystem = std::make_shared<VirtualFilesystem>();
 
   for (const auto &e : *m_cfb) {
     if (e.is_directory()) {

src/odr/internal/cfb/cfb_file.cpp

@@ -5,7 +5,7 @@
 
 namespace odr::internal::cfb {
 
-CfbFile::CfbFile(const std::shared_ptr<common::MemoryFile> &file)
+CfbFile::CfbFile(const std::shared_ptr<MemoryFile> &file)
     : m_cfb{std::make_shared<util::Archive>(file)} {}
 
 std::shared_ptr<abstract::File> CfbFile::file() const noexcept {

src/odr/internal/cfb/cfb_file.hpp

@@ -7,9 +7,9 @@ enum class FileType;
 struct FileMeta;
 } // namespace odr
 
-namespace odr::internal::common {
+namespace odr::internal {
 class MemoryFile;
-} // namespace odr::internal::common
+} // namespace odr::internal
 
 namespace odr::internal::cfb::util {
 class Archive;
@@ -19,7 +19,7 @@ namespace odr::internal::cfb {
 
 class CfbFile final : public abstract::ArchiveFile {
 public:
-  explicit CfbFile(const std::shared_ptr<common::MemoryFile> &file);
+  explicit CfbFile(const std::shared_ptr<MemoryFile> &file);
 
   [[nodiscard]] std::shared_ptr<abstract::File> file() const noexcept final;