Merge pull request #959 from PowerGridModel/feature/reduce-iterator-facade-complexity

reduce iterator facade complexity

Author: mgovers

power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp

@@ -140,10 +140,8 @@ template <typename T, dataset_type_tag dataset_type> class ColumnarAttributeRang
         constexpr auto dereference() const -> std::add_lvalue_reference_t<std::add_const_t<value_type>> {
             return current_;
         }
-        constexpr auto equal(iterator const& other) const { return current_.idx_ == other.current_.idx_; }
+        constexpr auto three_way_compare(iterator const& other) const { return current_.idx_ <=> other.current_.idx_; }
         constexpr auto distance_to(iterator const& other) const { return other.current_.idx_ - current_.idx_; }
-        constexpr void increment() { ++current_.idx_; }
-        constexpr void decrement() { --current_.idx_; }
         constexpr void advance(difference_type n) { current_.idx_ += n; }
 
         Proxy current_;

power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp

@@ -124,10 +124,6 @@ class SparseGroupedIdxVector {
             latest_value_ = value_type{(*indptr_)[group_], (*indptr_)[group_ + 1]};
             return latest_value_;
         }
-        constexpr auto equal(GroupIterator const& other) const {
-            assert(indptr_ == other.indptr_);
-            return group_ == other.group_;
-        }
         constexpr std::strong_ordering three_way_compare(GroupIterator const& other) const {
             assert(indptr_ == other.indptr_);
             return group_ <=> other.group_;
@@ -136,8 +132,6 @@ class SparseGroupedIdxVector {
             assert(indptr_ == other.indptr_);
             return other.group_ - group_;
         }
-        constexpr void increment() { ++group_; }
-        constexpr void decrement() { --group_; }
         constexpr void advance(Idx n) { group_ += n; }
     };
 
@@ -210,7 +204,6 @@ class DenseGroupedIdxVector {
                            narrow_cast<Idx>(std::distance(std::cbegin(*dense_vector_), group_range_.end()))};
             return latest_value_;
         }
-        constexpr auto equal(GroupIterator const& other) const { return group_ == other.group_; }
         constexpr std::strong_ordering three_way_compare(GroupIterator const& other) const {
             return group_ <=> other.group_;
         }

power_grid_model_c/power_grid_model/include/power_grid_model/common/iterator_facade.hpp

@@ -32,22 +32,26 @@ template <class Impl, typename ValueType, std::integral DifferenceType> class It
     constexpr auto operator->() -> decltype(auto) { return &(*(*this)); }
 
     friend constexpr bool operator==(IteratorFacade const& first, IteratorFacade const& second) {
-        return first.equal(second);
+        return (first <=> second) == std::strong_ordering::equivalent;
     }
-    friend constexpr std::strong_ordering operator<=>(IteratorFacade const& first, IteratorFacade const& second)
-        requires requires(const_iterator it) {
-            { it.three_way_compare(it) } -> std::convertible_to<std::strong_ordering>;
-        }
-    {
+    friend constexpr std::strong_ordering operator<=>(IteratorFacade const& first, IteratorFacade const& second) {
         return first.three_way_compare(second);
     }
 
     constexpr auto operator++() -> iterator& {
-        static_cast<iterator*>(this)->increment();
+        if constexpr (requires(iterator it) { it.increment(); }) {
+            static_cast<iterator*>(this)->increment();
+        } else {
+            static_cast<iterator*>(this)->advance(1);
+        }
         return *static_cast<iterator*>(this);
     }
     constexpr auto operator--() -> iterator& {
-        static_cast<iterator*>(this)->decrement();
+        if constexpr (requires(iterator it) { it.decrement(); }) {
+            static_cast<iterator*>(this)->decrement();
+        } else {
+            static_cast<iterator*>(this)->advance(-1);
+        }
         return *static_cast<iterator*>(this);
     }
     constexpr auto operator++(std::integral auto /*idx*/) -> iterator {
@@ -81,10 +85,6 @@ template <class Impl, typename ValueType, std::integral DifferenceType> class It
 
   private:
     // overloads for public bidirectional exposure (difference between MSVC and ClangCL)
-    constexpr bool equal(IteratorFacade const& other) const {
-        return static_cast<std::add_lvalue_reference_t<const_iterator>>(*this).equal(
-            static_cast<std::add_lvalue_reference_t<const_iterator>>(other));
-    }
     constexpr std::strong_ordering three_way_compare(IteratorFacade const& other) const {
         return static_cast<std::add_lvalue_reference_t<const_iterator>>(*this).three_way_compare(
             static_cast<std::add_lvalue_reference_t<const_iterator>>(other));

power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp

@@ -309,16 +309,10 @@ class Container<RetrievableTypes<GettableTypes...>, StorageableTypes...> {
             return container_ptr_->template get_item_by_seq<base_type>(idx_);
         }
         constexpr Gettable& dereference() { return container_ptr_->template get_item_by_seq<base_type>(idx_); }
-        constexpr bool equal(Iterator const& other) const {
-            assert(container_ptr_ == other.container_ptr_);
-            return idx_ == other.idx_;
-        }
         constexpr auto three_way_compare(Iterator const& other) const {
             assert(container_ptr_ == other.container_ptr_);
             return idx_ <=> other.idx_;
         }
-        constexpr void increment() { ++idx_; }
-        constexpr void decrement() { --idx_; }
         constexpr void advance(Idx n) { idx_ += n; }
         constexpr Idx distance_to(Iterator const& other) const {
             assert(container_ptr_ == other.container_ptr_);