post refactor cleanup

Author: andiwand

src/odr/definitions.hpp

@@ -2,37 +2,10 @@
 
 #include <cstdint>
 
-namespace odr::internal::abstract {
-class ElementAdapter;
-} // namespace odr::internal::abstract
-
 namespace odr {
 
 using ElementIdentifier = std::uint64_t;
 
 static constexpr ElementIdentifier null_element_id{0};
 
-struct ElementHandle final {
-  const internal::abstract::ElementAdapter *adapter_ptr{nullptr};
-  ElementIdentifier identifier{null_element_id};
-
-  ElementHandle() = default;
-  ElementHandle(const internal::abstract::ElementAdapter *adapter_ptr_,
-                const ElementIdentifier identifier_)
-      : adapter_ptr(adapter_ptr_), identifier(identifier_) {}
-  ElementHandle(const internal::abstract::ElementAdapter &adapter_,
-                const ElementIdentifier identifier_)
-      : adapter_ptr(&adapter_), identifier(identifier_) {}
-
-  [[nodiscard]] const internal::abstract::ElementAdapter &adapter() const {
-    return *adapter_ptr;
-  }
-
-  [[nodiscard]] bool is_null() const { return identifier == null_element_id; }
-
-  bool operator==(const ElementHandle &other) const {
-    return adapter_ptr == other.adapter_ptr && identifier == other.identifier;
-  }
-};
-
 } // namespace odr

src/odr/document.cpp

@@ -39,7 +39,7 @@ DocumentType Document::document_type() const noexcept {
 }
 
 Element Document::root_element() const {
-  return Element(m_impl->root_element());
+  return {m_impl->element_adapter(), m_impl->root_element()};
 }
 
 Filesystem Document::as_filesystem() const {

src/odr/document_element.cpp

@@ -12,9 +12,6 @@ namespace odr {
 
 Element::Element() = default;
 
-Element::Element(const ElementHandle &handle)
-    : m_adapter{handle.adapter_ptr}, m_identifier{handle.identifier} {}
-
 Element::Element(const internal::abstract::ElementAdapter *adapter,
                  const ElementIdentifier identifier)
     : m_adapter{adapter}, m_identifier{identifier} {}
@@ -30,23 +27,26 @@ ElementType Element::type() const {
 }
 
 Element Element::parent() const {
-  return exists_() ? Element(m_adapter->element_parent(m_identifier))
+  return exists_() ? Element(m_adapter, m_adapter->element_parent(m_identifier))
                    : Element();
 }
 
 Element Element::first_child() const {
-  return exists_() ? Element(m_adapter->element_first_child(m_identifier))
-                   : Element();
+  return exists_()
+             ? Element(m_adapter, m_adapter->element_first_child(m_identifier))
+             : Element();
 }
 
 Element Element::previous_sibling() const {
-  return exists_() ? Element(m_adapter->element_previous_sibling(m_identifier))
+  return exists_() ? Element(m_adapter,
+                             m_adapter->element_previous_sibling(m_identifier))
                    : Element();
 }
 
 Element Element::next_sibling() const {
-  return exists_() ? Element(m_adapter->element_next_sibling(m_identifier))
-                   : Element();
+  return exists_()
+             ? Element(m_adapter, m_adapter->element_next_sibling(m_identifier))
+             : Element();
 }
 
 bool Element::is_unique() const {
@@ -68,7 +68,8 @@ DocumentPath Element::document_path() const {
 
 Element Element::navigate_path(const DocumentPath &path) const {
   return exists_()
-             ? Element(m_adapter->element_navigate_path(m_identifier, path))
+             ? Element(m_adapter,
+                       m_adapter->element_navigate_path(m_identifier, path))
              : Element();
 }
 
@@ -168,17 +169,14 @@ Image Element::as_image() const {
 }
 
 ElementRange Element::children() const {
-  return {exists_()
-              ? ElementIterator(m_adapter->element_first_child(m_identifier))
-              : ElementIterator(),
+  return {exists_() ? ElementIterator(m_adapter, m_adapter->element_first_child(
+                                                     m_identifier))
+                    : ElementIterator(),
           ElementIterator()};
 }
 
 ElementIterator::ElementIterator() = default;
 
-ElementIterator::ElementIterator(const ElementHandle &handle)
-    : m_adapter{handle.adapter_ptr}, m_identifier{handle.identifier} {}
-
 ElementIterator::ElementIterator(
     const internal::abstract::ElementAdapter *adapter,
     const ElementIdentifier identifier)
@@ -188,10 +186,7 @@ Element ElementIterator::operator*() const { return {m_adapter, m_identifier}; }
 
 ElementIterator &ElementIterator::operator++() {
   if (exists_()) {
-    const auto [next_adapter, next_id] =
-        m_adapter->element_next_sibling(m_identifier);
-    m_adapter = next_adapter;
-    m_identifier = next_id;
+    m_identifier = m_adapter->element_next_sibling(m_identifier);
   }
   return *this;
 }
@@ -200,7 +195,7 @@ ElementIterator ElementIterator::operator++(int) const {
   if (!exists_()) {
     return {};
   }
-  return ElementIterator(m_adapter->element_next_sibling(m_identifier));
+  return {m_adapter, m_adapter->element_next_sibling(m_identifier)};
 }
 
 bool ElementIterator::exists_() const {
@@ -228,9 +223,9 @@ MasterPage TextRoot::first_master_page() const {
   if (!exists_()) {
     return {};
   }
-  const auto [master_page_adapter, master_page_id] =
+  const ElementIdentifier master_page_id =
       m_adapter2->text_root_first_master_page(m_identifier);
-  return {master_page_adapter, master_page_id,
+  return {m_adapter, master_page_id,
           m_adapter->master_page_adapter(master_page_id)};
 }
 
@@ -272,18 +267,21 @@ SheetCell Sheet::cell(const std::uint32_t column,
   if (!exists_()) {
     return {};
   }
-  const auto [cell_adapter, cell_id] =
+  const ElementIdentifier cell_id =
       m_adapter2->sheet_cell(m_identifier, column, row);
-  return {cell_adapter, cell_id, m_adapter->sheet_cell_adapter(cell_id)};
+  if (cell_id == null_element_id) {
+    return {};
+  }
+  return {m_adapter, cell_id, m_adapter->sheet_cell_adapter(cell_id)};
 }
 
 ElementRange Sheet::shapes() const {
   if (!exists_()) {
     return {};
   }
-  const auto [first_shape_adapter, first_shape_id] =
+  const ElementIdentifier first_shape_id =
       m_adapter2->sheet_first_shape(m_identifier);
-  return ElementRange(ElementIterator(first_shape_adapter, first_shape_id));
+  return ElementRange(ElementIterator(m_adapter, first_shape_id));
 }
 
 TableStyle Sheet::style() const {
@@ -397,29 +395,29 @@ TableRow Table::first_row() const {
   if (!exists_()) {
     return {};
   }
-  const auto [row_adapter, row_id] = m_adapter2->table_first_row(m_identifier);
-  return {row_adapter, row_id, m_adapter->table_row_adapter(row_id)};
+  const ElementIdentifier row_id = m_adapter2->table_first_row(m_identifier);
+  return {m_adapter, row_id, m_adapter->table_row_adapter(row_id)};
 }
 
 TableColumn Table::first_column() const {
   if (!exists_()) {
     return {};
   }
-  const auto [column_adapter, column_id] =
+  const ElementIdentifier column_id =
       m_adapter2->table_first_column(m_identifier);
-  return {column_adapter, column_id,
-          m_adapter->table_column_adapter(column_id)};
+  return {m_adapter, column_id, m_adapter->table_column_adapter(column_id)};
 }
 
 ElementRange Table::columns() const {
-  return exists_() ? ElementRange(ElementIterator(
-                         m_adapter2->table_first_column(m_identifier)))
-                   : ElementRange();
+  return exists_()
+             ? ElementRange(ElementIterator(
+                   m_adapter, m_adapter2->table_first_column(m_identifier)))
+             : ElementRange();
 }
 
 ElementRange Table::rows() const {
   return exists_() ? ElementRange(ElementIterator(
-                         m_adapter2->table_first_row(m_identifier)))
+                         m_adapter, m_adapter2->table_first_row(m_identifier)))
                    : ElementRange();
 }
 

src/odr/document_element.hpp

@@ -142,7 +142,6 @@ enum class ValueType {
 class Element {
 public:
   Element();
-  explicit Element(const ElementHandle &handle);
   Element(const internal::abstract::ElementAdapter *adapter,
           ElementIdentifier identifier);
 
@@ -208,7 +207,6 @@ class ElementIterator {
   using iterator_category = std::forward_iterator_tag;
 
   ElementIterator();
-  explicit ElementIterator(const ElementHandle &handle);
   ElementIterator(const internal::abstract::ElementAdapter *adapter,
                   ElementIdentifier identifier);
 
@@ -248,8 +246,6 @@ class ElementRange {
 template <typename T> class ElementBase : public Element {
 public:
   ElementBase() = default;
-  ElementBase(const ElementHandle &handle, const T *adapter2)
-      : Element(handle), m_adapter2{adapter2} {}
   ElementBase(const internal::abstract::ElementAdapter *adapter,
               ElementIdentifier identifier, const T *adapter2)
       : Element(adapter, identifier), m_adapter2{adapter2} {}