tidy

Author: andiwand

src/odr/document_element.cpp

@@ -229,6 +229,12 @@ SheetCell::SheetCell(const internal::abstract::Document *document,
     : TypedElement(document, element), m_sheet{sheet}, m_column{column},
       m_row{row} {}
 
+Sheet SheetCell::sheet() const { return Sheet(m_document, m_sheet); }
+
+std::uint32_t SheetCell::column() const { return m_column; }
+
+std::uint32_t SheetCell::row() const { return m_row; }
+
 bool SheetCell::is_covered() const {
   return exists_() ? m_element->is_covered(m_document) : false;
 }

src/odr/document_element.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <cstdint>
 #include <memory>
 #include <optional>
 #include <string>
@@ -87,6 +86,10 @@ enum class ElementType {
 
   master_page,
 
+  sheet_column,
+  sheet_row,
+  sheet_cell,
+
   text,
   line_break,
   page_break,
@@ -321,6 +324,9 @@ class SheetCell final : public TypedElement<internal::abstract::SheetCell> {
             internal::abstract::Sheet *sheet, std::uint32_t column,
             std::uint32_t row, internal::abstract::SheetCell *element);
 
+  [[nodiscard]] Sheet sheet() const;
+  [[nodiscard]] std::uint32_t column() const;
+  [[nodiscard]] std::uint32_t row() const;
   [[nodiscard]] bool is_covered() const;
   [[nodiscard]] TableDimensions span() const;
   [[nodiscard]] ValueType value_type() const;
@@ -530,7 +536,7 @@ class Image final : public TypedElement<internal::abstract::Image> {
   using TypedElement::TypedElement;
 
   [[nodiscard]] bool is_internal() const;
-  [[nodiscard]] std::optional<odr::File> file() const;
+  [[nodiscard]] std::optional<File> file() const;
   [[nodiscard]] std::string href() const;
 };
 

src/odr/internal/abstract/sheet_element.hpp

@@ -35,7 +35,7 @@ class Sheet : public virtual Element {
 class SheetCell : public virtual Element {
 public:
   [[nodiscard]] ElementType type(const Document *) const override {
-    return ElementType::table_cell;
+    return ElementType::sheet_cell;
   }
 
   [[nodiscard]] virtual bool is_covered(const Document *) const = 0;

src/odr/internal/ooxml/ooxml_crypto.cpp

@@ -11,14 +11,14 @@
 
 namespace {
 template <typename I, typename O> void to_little_endian(I in, O &out) {
-  for (std::size_t i = 0; i < sizeof(in); ++i) {
+  for (int i = 0; i < sizeof(in); ++i) {
     out[i] = in & 0xff;
     in >>= 8;
   }
 }
 
 template <typename I, typename O> void to_big_endian(I in, O &out) {
-  for (std::size_t i = sizeof(in) - 1; i >= 0; --i) {
+  for (int i = sizeof(in) - 1; i >= 0; --i) {
     out[i] = in & 0xff;
     in >>= 8;
   }
@@ -50,12 +50,12 @@ ECMA376Standard::ECMA376Standard(const EncryptionHeader &encryption_header,
 ECMA376Standard::ECMA376Standard(const std::string &encryption_info) {
   const char *offset = encryption_info.data() + sizeof(VersionInfo);
 
-  StandardHeader standard_header;
+  StandardHeader standard_header{};
   std::memcpy(&standard_header, offset, sizeof(standard_header));
   offset += sizeof(standard_header);
 
   std::memcpy(&m_encryption_header, offset, sizeof(m_encryption_header));
-  std::u16string csp_name_u16(
+  const std::u16string csp_name_u16(
       reinterpret_cast<const char16_t *>(offset + sizeof(m_encryption_header)));
   const std::string csp_name = util::string::u16string_to_string(csp_name_u16);
   offset += standard_header.encryption_header_size;
@@ -88,15 +88,15 @@ ECMA376Standard::derive_key(const std::string &password) const noexcept {
       to_little_endian(i, ibytes);
       hash = internal::crypto::util::sha1(ibytes + hash);
     }
-    to_little_endian((std::uint32_t)0, ibytes);
+    to_little_endian(static_cast<std::uint32_t>(0), ibytes);
     hash = internal::crypto::util::sha1(hash + ibytes);
   }
 
   std::string result;
   {
     const std::uint32_t cb_required_key_length =
         m_encryption_header.key_size / 8;
-    const std::uint32_t cb_hash = 20;
+    constexpr std::uint32_t cb_hash = 20;
 
     std::string buf1(64, '\x36');
     buf1 = xor_bytes(hash, buf1.substr(0, cb_hash)) + buf1.substr(cb_hash);
@@ -128,7 +128,7 @@ bool ECMA376Standard::verify(const std::string &key) const noexcept {
 std::string ECMA376Standard::decrypt(const std::string &encrypted_package,
                                      const std::string &key) const noexcept {
   const std::uint64_t total_size =
-      *(reinterpret_cast<const std::uint64_t *>(encrypted_package.data()));
+      *reinterpret_cast<const std::uint64_t *>(encrypted_package.data());
   std::string result =
       internal::crypto::util::decrypt_aes_ecb(key, encrypted_package.substr(8))
           .substr(0, total_size);
@@ -139,22 +139,22 @@ std::string ECMA376Standard::decrypt(const std::string &encrypted_package,
 Util::Util(const std::string &encryption_info) {
   {
     // big endian is not supported
-    const std::uint16_t num = 1;
-    if (*(reinterpret_cast<const std::uint8_t *>(&num)) != 1) {
+    constexpr std::uint16_t num = 1;
+    if (*reinterpret_cast<const std::uint8_t *>(&num) != 1) {
       throw UnsupportedEndian();
     }
   }
 
-  VersionInfo version_info;
+  VersionInfo version_info{};
   std::memcpy(&version_info, encryption_info.data(), sizeof(version_info));
-  if (((version_info.major == 2) || (version_info.major == 3) ||
-       (version_info.major == 4)) &&
-      (version_info.minor == 2)) {
+  if ((version_info.major == 2 || version_info.major == 3 ||
+       version_info.major == 4) &&
+      version_info.minor == 2) {
     impl = std::make_unique<ECMA376Standard>(encryption_info);
-  } else if ((version_info.major == 4) && (version_info.minor == 4)) {
+  } else if (version_info.major == 4 && version_info.minor == 4) {
     throw MsUnsupportedCryptoAlgorithm(); // agile
-  } else if (((version_info.major == 3) || (version_info.major == 4)) &&
-             (version_info.minor == 3)) {
+  } else if ((version_info.major == 3 || version_info.major == 4) &&
+             version_info.minor == 3) {
     throw MsUnsupportedCryptoAlgorithm(); // extensible
   } else {
     throw MsUnsupportedCryptoAlgorithm(); // unknown

src/odr/internal/ooxml/ooxml_crypto.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <cstdint>
 #include <memory>
 #include <string>
 
@@ -63,31 +62,31 @@ class ECMA376Standard final : public Algorithm {
   explicit ECMA376Standard(const std::string &encryption_info);
 
   [[nodiscard]] std::string
-  derive_key(const std::string &password) const noexcept final;
-  [[nodiscard]] bool verify(const std::string &key) const noexcept final;
+  derive_key(const std::string &password) const noexcept override;
+  [[nodiscard]] bool verify(const std::string &key) const noexcept override;
   [[nodiscard]] std::string
   decrypt(const std::string &encrypted_package,
-          const std::string &key) const noexcept final;
+          const std::string &key) const noexcept override;
 
 private:
   static constexpr auto ITER_COUNT = 50000;
 
-  EncryptionHeader m_encryption_header;
-  EncryptionVerifier m_encryption_verifier;
+  EncryptionHeader m_encryption_header{};
+  EncryptionVerifier m_encryption_verifier{};
   std::string m_encrypted_verifier_hash;
 };
 
 class Util final : public Algorithm {
 public:
   explicit Util(const std::string &encryption_info);
-  ~Util() noexcept final;
+  ~Util() noexcept override;
 
   [[nodiscard]] std::string
-  derive_key(const std::string &password) const noexcept final;
-  [[nodiscard]] bool verify(const std::string &key) const noexcept final;
+  derive_key(const std::string &password) const noexcept override;
+  [[nodiscard]] bool verify(const std::string &key) const noexcept override;
   [[nodiscard]] std::string
   decrypt(const std::string &encrypted_package,
-          const std::string &key) const noexcept final;
+          const std::string &key) const noexcept override;
 
 private:
   std::unique_ptr<Algorithm> impl;

src/odr/internal/ooxml/ooxml_file.cpp

@@ -13,10 +13,6 @@
 #include <odr/internal/util/stream_util.hpp>
 #include <odr/internal/zip/zip_file.hpp>
 
-namespace odr::internal::abstract {
-class Document;
-} // namespace odr::internal::abstract
-
 namespace odr::internal::ooxml {
 
 OfficeOpenXmlFile::OfficeOpenXmlFile(
@@ -65,20 +61,21 @@ OfficeOpenXmlFile::decrypt(const std::string &password) const {
     throw NotEncryptedError();
   }
 
-  std::string encryption_info = util::stream::read(
+  const std::string encryption_info = util::stream::read(
       *m_filesystem->open(AbsPath("/EncryptionInfo"))->stream());
   // TODO cache Crypto::Util
-  crypto::Util util(encryption_info);
-  std::string key = util.derive_key(password);
+  const crypto::Util util(encryption_info);
+  const std::string key = util.derive_key(password);
   if (!util.verify(key)) {
     throw WrongPasswordError();
   }
 
-  std::string encrypted_package = util::stream::read(
+  const std::string encrypted_package = util::stream::read(
       *m_filesystem->open(AbsPath("/EncryptedPackage"))->stream());
   std::string decrypted_package = util.decrypt(encrypted_package, key);
 
-  auto memory_file = std::make_shared<MemoryFile>(std::move(decrypted_package));
+  const auto memory_file =
+      std::make_shared<MemoryFile>(std::move(decrypted_package));
   auto decrypted = std::make_shared<OfficeOpenXmlFile>(*this);
   decrypted->m_filesystem =
       zip::ZipFile(memory_file).archive()->as_filesystem();

src/odr/internal/ooxml/ooxml_file.hpp

@@ -22,21 +22,21 @@ class OfficeOpenXmlFile final : public abstract::DocumentFile {
   explicit OfficeOpenXmlFile(
       std::shared_ptr<abstract::ReadableFilesystem> storage);
 
-  [[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]] DocumentType document_type() const final;
-  [[nodiscard]] DocumentMeta document_meta() const final;
+  [[nodiscard]] DocumentType document_type() const override;
+  [[nodiscard]] DocumentMeta document_meta() const override;
 
-  [[nodiscard]] bool password_encrypted() const noexcept final;
-  [[nodiscard]] EncryptionState encryption_state() const noexcept final;
-  [[nodiscard]] std::shared_ptr<abstract::DecodedFile>
-  decrypt(const std::string &password) const final;
+  [[nodiscard]] bool password_encrypted() const noexcept override;
+  [[nodiscard]] EncryptionState encryption_state() const noexcept override;
+  [[nodiscard]] std::shared_ptr<DecodedFile>
+  decrypt(const std::string &password) const override;
 
-  [[nodiscard]] std::shared_ptr<abstract::Document> document() const final;
+  [[nodiscard]] std::shared_ptr<abstract::Document> document() const override;
 
 private:
   std::shared_ptr<abstract::ReadableFilesystem> m_filesystem;

src/odr/internal/ooxml/ooxml_meta.hpp

@@ -1,8 +1,5 @@
 #pragma once
 
-#include <memory>
-#include <stdexcept>
-
 namespace odr {
 struct FileMeta;
 }