more cleanup

Author: andiwand

src/odr/document.cpp

@@ -8,8 +8,6 @@
 #include <odr/internal/abstract/document.hpp>
 #include <odr/internal/common/path.hpp>
 
-#include <stdexcept>
-
 namespace odr {
 
 Document::Document(std::shared_ptr<internal::abstract::Document> impl)

src/odr/document_element.cpp

@@ -121,7 +121,7 @@ bool ElementIterator::operator!=(const ElementIterator &rhs) const {
 }
 
 ElementIterator::reference ElementIterator::operator*() const {
-  return Element(m_document, m_element);
+  return {m_document, m_element};
 }
 
 ElementIterator &ElementIterator::operator++() {
@@ -142,10 +142,11 @@ bool ElementIterator::exists_() const { return m_element != nullptr; }
 
 ElementRange::ElementRange() = default;
 
-ElementRange::ElementRange(ElementIterator begin) : m_begin{std::move(begin)} {}
+ElementRange::ElementRange(const ElementIterator begin) : m_begin{begin} {}
 
-ElementRange::ElementRange(ElementIterator begin, ElementIterator end)
-    : m_begin{std::move(begin)}, m_end{std::move(end)} {}
+ElementRange::ElementRange(const ElementIterator begin,
+                           const ElementIterator end)
+    : m_begin{begin}, m_end{end} {}
 
 ElementIterator ElementRange::begin() const { return m_begin; }
 
@@ -182,19 +183,21 @@ TableDimensions Sheet::dimensions() const {
   return exists_() ? m_element->dimensions(m_document) : TableDimensions();
 }
 
-TableDimensions Sheet::content(std::optional<TableDimensions> range) const {
+TableDimensions
+Sheet::content(const std::optional<TableDimensions> range) const {
   return exists_() ? m_element->content(m_document, range) : TableDimensions();
 }
 
-SheetColumn Sheet::column(std::uint32_t column) const {
+SheetColumn Sheet::column(const std::uint32_t column) const {
   return exists_() ? SheetColumn(m_document, m_element, column) : SheetColumn();
 }
 
-SheetRow Sheet::row(std::uint32_t row) const {
+SheetRow Sheet::row(const std::uint32_t row) const {
   return exists_() ? SheetRow(m_document, m_element, row) : SheetRow();
 }
 
-SheetCell Sheet::cell(std::uint32_t column, std::uint32_t row) const {
+SheetCell Sheet::cell(const std::uint32_t column,
+                      const std::uint32_t row) const {
   return exists_() ? SheetCell(m_document, m_element, column, row,
                                m_element->cell(m_document, column, row))
                    : SheetCell();
@@ -207,7 +210,8 @@ ElementRange Sheet::shapes() const {
 }
 
 SheetColumn::SheetColumn(const internal::abstract::Document *document,
-                         internal::abstract::Sheet *sheet, std::uint32_t column)
+                         internal::abstract::Sheet *sheet,
+                         const std::uint32_t column)
     : TypedElement(document, sheet), m_column{column} {}
 
 TableColumnStyle SheetColumn::style() const {
@@ -216,20 +220,21 @@ TableColumnStyle SheetColumn::style() const {
 }
 
 SheetRow::SheetRow(const internal::abstract::Document *document,
-                   internal::abstract::Sheet *sheet, std::uint32_t row)
+                   internal::abstract::Sheet *sheet, const std::uint32_t row)
     : TypedElement(document, sheet), m_row{row} {}
 
 TableRowStyle SheetRow::style() const {
   return exists_() ? m_element->row_style(m_document, m_row) : TableRowStyle();
 }
 
 SheetCell::SheetCell(const internal::abstract::Document *document,
-                     internal::abstract::Sheet *sheet, std::uint32_t column,
-                     std::uint32_t row, internal::abstract::SheetCell *element)
+                     internal::abstract::Sheet *sheet,
+                     const std::uint32_t column, const std::uint32_t row,
+                     internal::abstract::SheetCell *element)
     : TypedElement(document, element), m_sheet{sheet}, m_column{column},
       m_row{row} {}
 
-Sheet SheetCell::sheet() const { return Sheet(m_document, m_sheet); }
+Sheet SheetCell::sheet() const { return {m_document, m_sheet}; }
 
 std::uint32_t SheetCell::column() const { return m_column; }
 

src/odr/document_path.cpp

@@ -50,7 +50,7 @@ DocumentPath::ComponentTemplate<Derived>::to_string() const noexcept {
 
 DocumentPath::Component
 DocumentPath::component_from_string(const std::string &string) {
-  auto colon = string.find(':');
+  const auto colon = string.find(':');
   if (colon == std::string::npos) {
     throw std::invalid_argument("string");
   }
@@ -60,24 +60,26 @@ DocumentPath::component_from_string(const std::string &string) {
 
   if (prefix == Child::prefix_string()) {
     return Child(number);
-  } else if (prefix == Column::prefix_string()) {
+  }
+  if (prefix == Column::prefix_string()) {
     return Column(number);
-  } else if (prefix == Row::prefix_string()) {
+  }
+  if (prefix == Row::prefix_string()) {
     return Row(number);
   }
 
   throw std::invalid_argument("string");
 }
 
-DocumentPath DocumentPath::extract(Element element) {
+DocumentPath DocumentPath::extract(const Element element) {
   return extract(element, {});
 }
 
-DocumentPath DocumentPath::extract(Element element, Element root) {
+DocumentPath DocumentPath::extract(const Element element, const Element root) {
   std::vector<Component> reverse;
 
   for (auto current = element; current != root;) {
-    auto parent = current.parent();
+    const auto parent = current.parent();
     if (!parent) {
       break;
     }
@@ -98,28 +100,28 @@ DocumentPath DocumentPath::extract(Element element, Element root) {
     current = parent;
   }
 
-  std::reverse(std::begin(reverse), std::end(reverse));
+  std::ranges::reverse(reverse);
   return DocumentPath(reverse);
 }
 
-Element DocumentPath::find(Element root, const DocumentPath &path) {
+Element DocumentPath::find(const Element root, const DocumentPath &path) {
   Element element = root;
 
-  for (const DocumentPath::Component &c : path) {
+  for (const Component &c : path) {
     std::uint32_t number = 0;
-    if (const auto child = std::get_if<DocumentPath::Child>(&c)) {
+    if (const auto child = std::get_if<Child>(&c)) {
       if (!element.first_child()) {
         throw std::invalid_argument("child not found");
       }
       element = element.first_child();
       number = child->number;
-    } else if (const auto column = std::get_if<DocumentPath::Column>(&c)) {
+    } else if (const auto column = std::get_if<Column>(&c)) {
       if (!element.as_table().first_column()) {
         throw std::invalid_argument("column not found");
       }
       element = Element(element.as_table().first_column());
       number = column->number;
-    } else if (const auto row = std::get_if<DocumentPath::Row>(&c)) {
+    } else if (const auto row = std::get_if<Row>(&c)) {
       if (!element.as_table().first_row()) {
         throw std::invalid_argument("row not found");
       }

src/odr/document_path.hpp

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <cstdint>
 #include <string>
 #include <variant>
 #include <vector>
@@ -28,17 +27,17 @@ class DocumentPath final {
     [[nodiscard]] std::string to_string() const noexcept;
   };
 
-  struct Child final : public ComponentTemplate<Child> {
+  struct Child final : ComponentTemplate<Child> {
     static constexpr std::string_view prefix = "child";
     using ComponentTemplate::ComponentTemplate;
   };
 
-  struct Column final : public ComponentTemplate<Column> {
+  struct Column final : ComponentTemplate<Column> {
     static constexpr std::string_view prefix = "column";
     using ComponentTemplate::ComponentTemplate;
   };
 
-  struct Row final : public ComponentTemplate<Row> {
+  struct Row final : ComponentTemplate<Row> {
     static constexpr std::string_view prefix = "row";
     using ComponentTemplate::ComponentTemplate;
   };