more cleanup

Author: andiwand

src/odr/internal/abstract/document_element.hpp

@@ -2,7 +2,6 @@
 
 #include <odr/document_element.hpp>
 
-#include <memory>
 #include <optional>
 #include <string>
 
@@ -41,8 +40,7 @@ class Element {
   [[nodiscard]] virtual Element *previous_sibling(const Document *) const = 0;
   [[nodiscard]] virtual Element *next_sibling(const Document *) const = 0;
 
-  [[nodiscard]] virtual bool
-  is_editable(const abstract::Document *document) const = 0;
+  [[nodiscard]] virtual bool is_editable(const Document *document) const = 0;
 };
 
 class TextRoot : public virtual Element {
@@ -53,8 +51,7 @@ class TextRoot : public virtual Element {
 
   [[nodiscard]] virtual PageLayout page_layout(const Document *) const = 0;
 
-  [[nodiscard]] virtual abstract::Element *
-  first_master_page(const Document *) const = 0;
+  [[nodiscard]] virtual Element *first_master_page(const Document *) const = 0;
 };
 
 class Slide : public virtual Element {
@@ -290,8 +287,7 @@ class Image : public virtual Element {
   }
 
   [[nodiscard]] virtual bool is_internal(const Document *) const = 0;
-  [[nodiscard]] virtual std::optional<odr::File>
-  file(const Document *) const = 0;
+  [[nodiscard]] virtual std::optional<File> file(const Document *) const = 0;
   [[nodiscard]] virtual std::string href(const Document *) const = 0;
 };
 

src/odr/internal/abstract/filesystem.hpp

@@ -40,7 +40,7 @@ class ReadableFilesystem {
   [[nodiscard]] virtual std::unique_ptr<FileWalker>
   file_walker(const AbsPath &path) const = 0;
 
-  [[nodiscard]] virtual std::shared_ptr<abstract::File>
+  [[nodiscard]] virtual std::shared_ptr<File>
   open(const AbsPath &path) const = 0;
 };
 
@@ -53,10 +53,9 @@ class WriteableFilesystem {
 
   virtual bool remove(const AbsPath &path) = 0;
   virtual bool copy(const AbsPath &from, const AbsPath &to) = 0;
-  virtual std::shared_ptr<abstract::File> copy(const abstract::File &from,
-                                               const AbsPath &to) = 0;
-  virtual std::shared_ptr<abstract::File>
-  copy(std::shared_ptr<abstract::File> from, const AbsPath &to) = 0;
+  virtual std::shared_ptr<File> copy(const File &from, const AbsPath &to) = 0;
+  virtual std::shared_ptr<File> copy(std::shared_ptr<File> from,
+                                     const AbsPath &to) = 0;
   virtual bool move(const AbsPath &from, const AbsPath &to) = 0;
 };
 

src/odr/internal/abstract/html_service.hpp

@@ -3,7 +3,6 @@
 #include <odr/html.hpp>
 
 #include <iosfwd>
-#include <memory>
 #include <optional>
 
 namespace odr {

src/odr/internal/cfb/cfb_archive.cpp

@@ -3,7 +3,6 @@
 #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 {
 class File;

src/odr/internal/cfb/cfb_archive.hpp

@@ -1,13 +1,8 @@
 #pragma once
 
 #include <odr/internal/abstract/archive.hpp>
-#include <odr/internal/common/file.hpp>
-#include <odr/internal/common/path.hpp>
 
-#include <iterator>
 #include <memory>
-#include <optional>
-#include <string>
 #include <vector>
 
 namespace odr {
@@ -34,9 +29,9 @@ class CfbArchive final : public abstract::Archive {
   explicit CfbArchive(std::shared_ptr<util::Archive> archive);
 
   [[nodiscard]] std::shared_ptr<abstract::Filesystem>
-  as_filesystem() const final;
+  as_filesystem() const override;
 
-  void save(std::ostream &out) const final;
+  void save(std::ostream &out) const override;
 
 private:
   std::shared_ptr<util::Archive> m_cfb;

src/odr/internal/cfb/cfb_file.hpp

@@ -21,13 +21,13 @@ class CfbFile final : public abstract::ArchiveFile {
 public:
   explicit CfbFile(const std::shared_ptr<MemoryFile> &file);
 
-  [[nodiscard]] std::shared_ptr<abstract::File> file() const noexcept final;
+  [[nodiscard]] std::shared_ptr<abstract::File> file() const noexcept override;
 
-  [[nodiscard]] FileType file_type() const noexcept final;
-  [[nodiscard]] FileMeta file_meta() const noexcept final;
-  [[nodiscard]] DecoderEngine decoder_engine() const noexcept final;
+  [[nodiscard]] FileType file_type() const noexcept override;
+  [[nodiscard]] FileMeta file_meta() const noexcept override;
+  [[nodiscard]] DecoderEngine decoder_engine() const noexcept override;
 
-  [[nodiscard]] std::shared_ptr<abstract::Archive> archive() const final;
+  [[nodiscard]] std::shared_ptr<abstract::Archive> archive() const override;
 
 private:
   std::shared_ptr<util::Archive> m_cfb;

src/odr/internal/cfb/cfb_impl.cpp

@@ -41,7 +41,7 @@ CompoundFileReader::CompoundFileReader(const void *buffer,
 
   m_sector_size = m_hdr->major_version == 3 ? 512 : 4096;
 
-  // The file must contains at least 3 sectors
+  // The file must contain at least 3 sectors
   if (m_buffer_len < m_sector_size * 3) {
     throw CfbFileCorrupted();
   }
@@ -54,7 +54,8 @@ CompoundFileReader::CompoundFileReader(const void *buffer,
   m_mini_stream_start_sector = root->start_sector_location;
 }
 
-const CompoundFileEntry *CompoundFileReader::get_entry(size_t entry_id) const {
+const CompoundFileEntry *
+CompoundFileReader::get_entry(const std::size_t entry_id) const {
   if (entry_id == 0xFFFFFFFF) {
     return nullptr;
   }
@@ -94,9 +95,9 @@ void CompoundFileReader::read_file(const CompoundFileEntry *entry,
 }
 
 void CompoundFileReader::enum_files(const CompoundFileEntry *entry,
-                                    int max_level,
+                                    const int max_level,
                                     const EnumFilesCallback &callback) const {
-  std::u16string dir;
+  const std::u16string dir;
   enum_nodes(get_entry(entry->child_id), 0, max_level, dir, callback);
 }
 
@@ -114,10 +115,10 @@ void CompoundFileReader::enum_nodes(const CompoundFileEntry *entry,
 
   callback(entry, dir, current_level + 1);
 
-  const CompoundFileEntry *child = get_entry(entry->child_id);
-  if (child != nullptr) {
+  if (const CompoundFileEntry *child = get_entry(entry->child_id);
+      child != nullptr) {
     std::u16string new_dir = dir;
-    if (dir.length() != 0) {
+    if (!dir.empty()) {
       new_dir.push_back('/');
     }
     new_dir.append(reinterpret_cast<const char16_t *>(entry->name),
@@ -141,7 +142,7 @@ void CompoundFileReader::read_stream(std::size_t sector, std::size_t offset,
   // -->   m_sectorSize  --> ... -->    remaining
   while (len > 0) {
     const std::uint8_t *src = sector_offset_to_address(sector, offset);
-    std::size_t copylen = std::min(len, m_sector_size - offset);
+    const std::size_t copylen = std::min(len, m_sector_size - offset);
     if (m_buffer + m_buffer_len < src + copylen) {
       throw CfbFileCorrupted();
     }
@@ -164,7 +165,7 @@ void CompoundFileReader::read_mini_stream(std::size_t sector,
   // -->   m_sectorSize  --> ... -->    remaining
   while (len > 0) {
     const std::uint8_t *src = mini_sector_offset_to_address(sector, offset);
-    std::size_t copylen = std::min(len, m_mini_sector_size - offset);
+    const std::size_t copylen = std::min(len, m_mini_sector_size - offset);
     if (m_buffer + m_buffer_len < src + copylen) {
       throw CfbFileCorrupted();
     }
@@ -177,25 +178,28 @@ void CompoundFileReader::read_mini_stream(std::size_t sector,
   }
 }
 
-std::size_t CompoundFileReader::get_next_sector(size_t sector) const {
+std::size_t
+CompoundFileReader::get_next_sector(const std::size_t sector) const {
   // lookup FAT
-  std::size_t entriesPerSector = m_sector_size / 4;
-  std::size_t fatSectorNumber = sector / entriesPerSector;
-  std::size_t fatSectorLocation = get_fat_sector_location(fatSectorNumber);
+  const std::size_t entriesPerSector = m_sector_size / 4;
+  const std::size_t fatSectorNumber = sector / entriesPerSector;
+  const std::size_t fatSectorLocation =
+      get_fat_sector_location(fatSectorNumber);
   return parse_uint32(sector_offset_to_address(fatSectorLocation,
                                                sector % entriesPerSector * 4));
 }
 
-std::size_t CompoundFileReader::get_next_mini_sector(size_t mini_sector) const {
+std::size_t
+CompoundFileReader::get_next_mini_sector(const std::size_t mini_sector) const {
   std::size_t sector, offset;
   locate_final_sector(m_hdr->first_mini_fat_sector_location, mini_sector * 4,
                       &sector, &offset);
   return parse_uint32(sector_offset_to_address(sector, offset));
 }
 
 const std::uint8_t *
-CompoundFileReader::sector_offset_to_address(size_t sector,
-                                             size_t offset) const {
+CompoundFileReader::sector_offset_to_address(const std::size_t sector,
+                                             const std::size_t offset) const {
   if (sector >= MAX_REG_SECT || offset >= m_sector_size ||
       m_buffer_len <= static_cast<std::uint64_t>(m_sector_size) * sector +
                           m_sector_size + offset) {
@@ -249,7 +253,7 @@ std::size_t CompoundFileReader::get_fat_sector_location(
   }
 
   fat_sector_number -= 109;
-  std::size_t entriesPerSector = m_sector_size / 4 - 1;
+  const std::size_t entriesPerSector = m_sector_size / 4 - 1;
   std::size_t difatSectorLocation = m_hdr->first_difat_sector_location;
   while (fat_sector_number >= entriesPerSector) {
     fat_sector_number -= entriesPerSector;
@@ -273,15 +277,18 @@ PropertySet::PropertySet(const void *buffer, const std::size_t len,
   }
 }
 
-const std::uint16_t *PropertySet::get_string_property(uint32_t property_id) {
+const std::uint16_t *
+PropertySet::get_string_property(const std::uint32_t property_id) {
   for (std::uint32_t i = 0; i < m_hdr->num_properties; i++) {
     if (m_hdr->property_identifier_and_offset[i].id == property_id) {
-      std::uint32_t offset = m_hdr->property_identifier_and_offset[i].offset;
+      const std::uint32_t offset =
+          m_hdr->property_identifier_and_offset[i].offset;
       if (m_buffer_len < offset + 8) {
         throw CfbFileCorrupted();
       }
-      std::uint32_t stringLengthInChar = parse_uint32(m_buffer + offset + 4);
-      if (m_buffer_len < offset + 8 + stringLengthInChar * 2) {
+      if (const std::uint32_t stringLengthInChar =
+              parse_uint32(m_buffer + offset + 4);
+          m_buffer_len < offset + 8 + stringLengthInChar * 2) {
         throw CfbFileCorrupted();
       }
       return reinterpret_cast<const std::uint16_t *>(m_buffer + offset + 8);
@@ -307,15 +314,15 @@ std::size_t PropertySetStream::get_property_set_count() {
   return m_hdr->num_property_sets;
 }
 
-PropertySet PropertySetStream::get_property_set(size_t index) {
+PropertySet PropertySetStream::get_property_set(const std::size_t index) {
   if (index >= get_property_set_count()) {
     throw CfbFileCorrupted();
   }
-  std::uint32_t offset = m_hdr->property_set_info[index].offset;
+  const std::uint32_t offset = m_hdr->property_set_info[index].offset;
   if (m_buffer_len < offset + 4) {
     throw CfbFileCorrupted();
   }
-  std::uint32_t size = parse_uint32(m_buffer + offset);
+  const std::uint32_t size = parse_uint32(m_buffer + offset);
   if (m_buffer_len < offset + size) {
     throw CfbFileCorrupted();
   }

src/odr/internal/cfb/cfb_impl.hpp

@@ -135,7 +135,6 @@ class CompoundFileReader final {
   [[nodiscard]] std::size_t
   get_fat_sector_location(std::size_t fat_sector_number) const;
 
-private:
   const std::uint8_t *m_buffer;
   std::size_t m_buffer_len;