power-grid-model 1.12.48__tar.gz → 1.12.50__tar.gz

{power_grid_model-1.12.48 → power_grid_model-1.12.50}/.github/workflows/reuse-compliance.yml

@@ -21,4 +21,4 @@ jobs:
     - name: checkout
       uses: actions/checkout@v5
     - name: REUSE Compliance Check
-      uses: fsfe/reuse-action@v5
+      uses: fsfe/reuse-action@v6

{power_grid_model-1.12.48 → power_grid_model-1.12.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: power-grid-model
-Version: 1.12.48
+Version: 1.12.50
 Summary: Python/C++ library for distribution power system analysis
 Author-Email: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
 License-Expression: MPL-2.0

power_grid_model-1.12.50/VERSION

@@ -0,0 +1 @@
+1.12.50

{power_grid_model-1.12.48 → power_grid_model-1.12.50}/power_grid_model_c/power_grid_model/include/power_grid_model/auxiliary/dataset.hpp

@@ -117,28 +117,38 @@ class ColumnarAttributeRange : public std::ranges::view_interface<ColumnarAttrib
         std::span<AttributeBuffer<Data> const> attribute_buffers_{};
     };
 
-    class iterator
-        : public IteratorFacade<iterator, std::conditional_t<is_data_mutable_v<dataset_type>, Proxy, Proxy const>,
-                                Idx> {
+    class iterator : public IteratorFacade {
       public:
-        using value_type = Proxy;
+        using value_type = std::conditional_t<is_data_mutable_v<dataset_type>, Proxy, Proxy const>;
         using difference_type = Idx;
+        using pointer = std::add_pointer_t<value_type>;
+        using reference = std::add_lvalue_reference_t<value_type>;
 
-        iterator() = default;
+        iterator() : IteratorFacade{*this} {};
         iterator(difference_type idx, std::span<AttributeBuffer<Data> const> attribute_buffers)
-            : current_{idx, attribute_buffers} {}
+            : IteratorFacade{*this}, current_{idx, attribute_buffers} {}
 
-      private:
-        friend class IteratorFacade<iterator, std::conditional_t<is_data_mutable_v<dataset_type>, Proxy, Proxy const>,
-                                    Idx>;
-
-        constexpr auto dereference() -> value_type& { return current_; }
-        constexpr auto dereference() const -> std::add_lvalue_reference_t<std::add_const_t<value_type>> {
+        constexpr auto operator*() -> reference { return current_; }
+        constexpr auto operator*() const -> std::add_lvalue_reference_t<std::add_const_t<value_type>> {
             return current_;
         }
-        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 advance(difference_type n) { current_.idx_ += n; }
+
+        friend constexpr auto operator<=>(iterator const& first, iterator const& second) {
+            return first.current_idx() <=> second.current_idx();
+        }
+
+        constexpr auto operator+=(difference_type n) -> std::add_lvalue_reference_t<iterator> {
+            current_idx() += n;
+            return *this;
+        }
+
+        friend constexpr auto operator-(iterator const& first, iterator const& second) -> difference_type {
+            return first.current_idx() - second.current_idx();
+        }
+
+      private:
+        constexpr auto current_idx() const { return current_.idx_; }
+        constexpr auto& current_idx() { return current_.idx_; }
 
         Proxy current_;
     };

{power_grid_model-1.12.48 → power_grid_model-1.12.50}/power_grid_model_c/power_grid_model/include/power_grid_model/common/grouped_index_vector.hpp

@@ -94,26 +94,20 @@ constexpr auto from_dense = from_dense_t{};
 
 class SparseGroupedIdxVector {
   private:
-    class GroupIterator : public IteratorFacade<GroupIterator, IdxRange const, Idx> {
-        friend class IteratorFacade<GroupIterator, IdxRange const, Idx>;
-        using Base = IteratorFacade<GroupIterator, IdxRange const, Idx>;
-
+    class GroupIterator : public IteratorFacade {
       public:
-        using value_type = typename Base::value_type;
-        using difference_type = typename Base::difference_type;
-        using reference = typename Base::reference;
-
-        GroupIterator() = default;
-        explicit constexpr GroupIterator(IdxVector const& indptr, Idx group) : indptr_{&indptr}, group_{group} {}
-
-      private:
-        IdxVector const* indptr_{};
-        Idx group_{};
-        mutable value_type latest_value_{}; // making this mutable allows us to delay out-of-bounds checks until
-                                            // dereferencing instead of update methods. Note that the value will be
-                                            // invalidated at first update
-
-        constexpr auto dereference() const -> reference {
+        using iterator = GroupIterator;
+        using const_iterator = std::add_const_t<GroupIterator>;
+        using value_type = IdxRange const;
+        using difference_type = Idx;
+        using pointer = std::add_pointer_t<value_type>;
+        using reference = std::add_lvalue_reference_t<value_type>;
+
+        GroupIterator() : IteratorFacade{*this} {};
+        explicit constexpr GroupIterator(IdxVector const& indptr, Idx group)
+            : IteratorFacade{*this}, indptr_{&indptr}, group_{group} {}
+
+        constexpr auto operator*() const -> reference {
             assert(indptr_ != nullptr);
             assert(0 <= group_);
             assert(group_ < static_cast<Idx>(indptr_->size() - 1));
@@ -123,15 +117,29 @@ class SparseGroupedIdxVector {
             latest_value_ = value_type{(*indptr_)[group_], (*indptr_)[group_ + 1]};
             return latest_value_;
         }
-        constexpr std::strong_ordering three_way_compare(GroupIterator const& other) const {
-            assert(indptr_ == other.indptr_);
-            return group_ <=> other.group_;
+
+        friend constexpr std::strong_ordering operator<=>(GroupIterator const& first, GroupIterator const& second) {
+            assert(first.indptr_ == second.indptr_);
+            return first.group_ <=> second.group_;
+        }
+
+        constexpr auto operator+=(difference_type n) -> std::add_lvalue_reference_t<GroupIterator> {
+            group_ += n;
+            return *this;
         }
-        constexpr auto distance_to(GroupIterator const& other) const {
-            assert(indptr_ == other.indptr_);
-            return other.group_ - group_;
+
+        friend auto operator-(GroupIterator const& first, GroupIterator const& second) -> difference_type {
+            assert(first.indptr_ == second.indptr_);
+            return first.group_ - second.group_;
         }
-        constexpr void advance(Idx n) { group_ += n; }
+
+      private:
+        IdxVector const* indptr_{};
+        Idx group_{};
+        mutable std::remove_const_t<value_type>
+            latest_value_{}; // making this mutable allows us to delay out-of-bounds checks until
+                             // dereferencing instead of update methods. Note that the value will be
+                             // invalidated at first update
     };
 
     constexpr auto group_iterator(Idx group) const { return GroupIterator{indptr_, group}; }
@@ -168,32 +176,25 @@ class SparseGroupedIdxVector {
 
 class DenseGroupedIdxVector {
   private:
-    class GroupIterator : public IteratorFacade<GroupIterator, IdxRange const, Idx> {
-        friend class IteratorFacade<GroupIterator, IdxRange const, Idx>;
-        using Base = IteratorFacade<GroupIterator, IdxRange const, Idx>;
+    class GroupIterator : public IteratorFacade {
+        friend class IteratorFacade; // to expose increment and decrement
 
       public:
-        using value_type = typename Base::value_type;
-        using difference_type = typename Base::difference_type;
-        using reference = typename Base::reference;
-
-        GroupIterator() = default;
+        using iterator = GroupIterator;
+        using const_iterator = std::add_const_t<GroupIterator>;
+        using value_type = IdxRange const;
+        using difference_type = Idx;
+        using pointer = std::add_pointer_t<value_type>;
+        using reference = std::add_lvalue_reference_t<value_type>;
+
+        GroupIterator() : IteratorFacade{*this} {};
         explicit constexpr GroupIterator(IdxVector const& dense_vector, Idx group)
-            : dense_vector_{&dense_vector},
+            : IteratorFacade{*this},
+              dense_vector_{&dense_vector},
               group_{group},
               group_range_{std::ranges::equal_range(*dense_vector_, group)} {}
 
-      private:
-        using group_iterator = IdxVector::const_iterator;
-
-        IdxVector const* dense_vector_{};
-        Idx group_{};
-        std::ranges::subrange<group_iterator> group_range_;
-        mutable value_type latest_value_{}; // making this mutable allows us to delay out-of-bounds checks until
-                                            // dereferencing instead of update methods. Note that the value will be
-                                            // invalidated at first update
-
-        constexpr auto dereference() const -> reference {
+        constexpr auto operator*() const -> reference {
             assert(dense_vector_ != nullptr);
 
             // delaying out-of-bounds checking until dereferencing while still returning a reference type requires
@@ -203,10 +204,31 @@ class DenseGroupedIdxVector {
                            narrow_cast<Idx>(std::distance(std::cbegin(*dense_vector_), group_range_.end()))};
             return latest_value_;
         }
-        constexpr std::strong_ordering three_way_compare(GroupIterator const& other) const {
-            return group_ <=> other.group_;
+
+        friend constexpr std::strong_ordering operator<=>(GroupIterator const& first, GroupIterator const& second) {
+            assert(first.dense_vector_ == second.dense_vector_);
+            return first.group_ <=> second.group_;
+        }
+
+        constexpr auto operator+=(difference_type n) -> std::add_lvalue_reference_t<GroupIterator> {
+            advance(n);
+            return *this;
         }
-        constexpr auto distance_to(GroupIterator const& other) const { return other.group_ - group_; }
+        friend auto operator-(GroupIterator const& first, GroupIterator const& second) -> difference_type {
+            assert(first.dense_vector_ == second.dense_vector_);
+            return first.group_ - second.group_;
+        }
+
+      private:
+        using group_iterator = IdxVector::const_iterator;
+
+        IdxVector const* dense_vector_{};
+        Idx group_{};
+        std::ranges::subrange<group_iterator> group_range_;
+        mutable std::remove_const_t<value_type>
+            latest_value_{}; // making this mutable allows us to delay out-of-bounds checks until
+                             // dereferencing instead of update methods. Note that the value will be
+                             // invalidated at first update
 
         constexpr void increment() {
             ++group_;
@@ -220,7 +242,7 @@ class DenseGroupedIdxVector {
                                 .base(),
                             group_range_.begin()};
         }
-        constexpr void advance(Idx n) {
+        constexpr void advance(difference_type n) {
             auto const start = n > 0 ? group_range_.end() : std::cbegin(*dense_vector_);
             auto const stop = n < 0 ? group_range_.begin() : std::cend(*dense_vector_);
 

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

@@ -0,0 +1,121 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#pragma once
+
+#include "common.hpp"
+
+#include <concepts>
+#include <ranges>
+#include <utility>
+
+namespace power_grid_model {
+namespace detail {
+template <typename T>
+concept iterator_facadeable_c = std::integral<typename T::difference_type> && std::is_pointer_v<typename T::pointer> &&
+                                std::is_lvalue_reference_v<typename T::reference> &&
+                                requires(T t, std::remove_cvref_t<T> mt, std::add_const_t<T> ct,
+                                         std::add_const_t<T> ct2, typename std::remove_cvref_t<T>::difference_type d) {
+                                    typename T::value_type;
+                                    { *t } -> std::same_as<typename T::reference>;
+                                    { &*t } -> std::same_as<typename T::pointer>;
+                                    { ct <=> ct2 } -> std::same_as<std::strong_ordering>;
+                                    { mt += d } -> std::same_as<std::add_lvalue_reference_t<T>>;
+                                    { ct - ct2 } -> std::same_as<typename T::difference_type>;
+                                };
+
+template <typename T, typename Int>
+concept compound_assignable_c = requires(T t, Int n) {
+    { t += n } -> std::same_as<std::add_lvalue_reference_t<T>>;
+};
+} // namespace detail
+
+class IteratorFacade {
+  public:
+    using iterator_category = std::random_access_iterator_tag;
+
+    template <typename Self> constexpr decltype(auto) operator->(this Self&& self) {
+        return &(*std::forward<Self>(self));
+    }
+
+    template <typename Self, typename Other>
+        requires std::same_as<std::remove_cvref_t<Self>, std::remove_cvref_t<Other>>
+    constexpr bool operator==(this Self const& self, Other const& other) {
+        return (self <=> other) == std::strong_ordering::equivalent;
+    }
+
+    // NOLINTNEXTLINE(cert-dcl21-cpp) // pre-decrement but clang-tidy incorrectly sees this as post-decrement
+    template <typename Self> constexpr std::add_lvalue_reference_t<Self> operator++(this Self& self) {
+        if constexpr (requires { self.increment(); }) { // NOTE: IteratorFacade should be a friend class
+            self.increment();
+        } else {
+            return (self += 1);
+        }
+        return self;
+    }
+    // NOLINTNEXTLINE(cert-dcl21-cpp) // pre-decrement but clang-tidy incorrectly sees this as post-decrement
+    template <typename Self> constexpr std::add_lvalue_reference_t<Self> operator--(this Self& self) {
+        if constexpr (requires { self.decrement(); }) { // NOTE: IteratorFacade should be a friend class
+            self.decrement();
+        } else {
+            return (self += -1);
+        }
+        return self;
+    }
+    template <typename Self>
+    constexpr std::remove_cvref_t<Self> operator++(this Self& self, std::integral auto /*idx*/) {
+        using Result = std::remove_cvref_t<Self>;
+        Result result{self};
+        ++self;
+        return result;
+    }
+    template <typename Self>
+    constexpr std::remove_cvref_t<Self> operator--(this Self& self, std::integral auto /*idx*/) {
+        using Result = std::remove_cvref_t<Self>;
+        Result result{self};
+        --self;
+        return result;
+    }
+    template <typename Self>
+    constexpr std::add_lvalue_reference_t<Self> operator-=(this Self& self, std::integral auto idx) {
+        return (self += (-idx));
+    }
+
+    template <typename Self, std::integral Int>
+    friend constexpr std::remove_cvref_t<Self> operator+(Self&& self, Int offset)
+        requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
+    {
+        using Result = std::remove_cvref_t<Self>;
+        Result result{std::forward<Self>(self)};
+        result += offset;
+        return result;
+    }
+    template <typename Self, std::integral Int>
+        requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
+    friend constexpr std::remove_cvref_t<Self> operator+(Int offset, Self&& self) {
+        return std::forward<Self>(self) + offset;
+    }
+    template <typename Self, std::integral Int>
+        requires std::derived_from<std::remove_cvref_t<Self>, IteratorFacade> //&& detail::iterator_facadeable_c<Self>
+    friend constexpr std::remove_cvref_t<Self> operator-(Self&& self, Int idx) {
+        return (std::forward<Self>(self)) + (-idx);
+    }
+
+    template <typename Self>
+    constexpr decltype(auto) operator[](this Self const& self, typename Self::difference_type idx) {
+        return *(self + idx);
+    }
+
+    // prevent construction by non-derived and non-iterator-facadeable types
+    IteratorFacade() = delete;
+    template <typename Self> constexpr explicit IteratorFacade(Self& /*self*/) {
+        // cannot be done using constraints because the type is not fully instantiated yet when the compiler
+        // instantiates the constructor. Note that this is different from the other methods because those are only
+        // instantiated when used.
+        static_assert(std::derived_from<std::remove_cvref_t<Self>, IteratorFacade>);
+        static_assert(detail::iterator_facadeable_c<std::remove_cvref_t<Self>>);
+    }
+};
+
+} // namespace power_grid_model

{power_grid_model-1.12.48 → power_grid_model-1.12.50}/power_grid_model_c/power_grid_model/include/power_grid_model/container.hpp

@@ -286,15 +286,19 @@ class Container<RetrievableTypes<GettableTypes...>, StorageableTypes...> {
     }
 
     // define iterator
-    template <supported_type_c<GettableTypes...> Gettable>
-    class Iterator : public IteratorFacade<Iterator<Gettable>, Gettable, Idx> {
+    template <supported_type_c<GettableTypes...> Gettable> class Iterator : public IteratorFacade {
       public:
+        using value_type = Gettable;
+        using difference_type = Idx;
+        using pointer = std::add_pointer_t<value_type>;
+        using reference = std::add_lvalue_reference_t<value_type>;
+
         static constexpr bool is_const = std::is_const_v<Gettable>;
         using base_type = std::remove_cv_t<Gettable>;
         using container_type = std::conditional_t<is_const, Container const, Container>;
         // constructor including default
         explicit Iterator(container_type* container_ptr = nullptr, Idx idx = 0)
-            : container_ptr_{container_ptr}, idx_{idx} {}
+            : IteratorFacade{*this}, container_ptr_{container_ptr}, idx_{idx} {}
         // conversion to const iterator
         template <class ConstGettable = Gettable>
             requires(!is_const)
@@ -302,23 +306,28 @@ class Container<RetrievableTypes<GettableTypes...>, StorageableTypes...> {
             return Iterator<ConstGettable const>{container_ptr_, idx_};
         }
 
-      private:
-        friend class IteratorFacade<Iterator<Gettable>, Gettable, Idx>;
-
-        constexpr Gettable const& dereference() const {
+        constexpr Gettable const& operator*() const {
             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 auto three_way_compare(Iterator const& other) const {
-            assert(container_ptr_ == other.container_ptr_);
-            return idx_ <=> other.idx_;
+        constexpr Gettable& operator*() { return container_ptr_->template get_item_by_seq<base_type>(idx_); }
+
+        constexpr auto operator+=(Idx n) -> std::add_lvalue_reference_t<Iterator> {
+            idx_ += n;
+            return *this;
         }
-        constexpr void advance(Idx n) { idx_ += n; }
-        constexpr Idx distance_to(Iterator const& other) const {
-            assert(container_ptr_ == other.container_ptr_);
-            return other.idx_ - idx_;
+
+        friend constexpr auto operator<=>(Iterator const& first, Iterator const& second) -> std::strong_ordering {
+            assert(first.container_ptr_ == second.container_ptr_);
+            return first.idx_ <=> second.idx_;
+        }
+        friend constexpr auto operator-(Iterator const& first, Iterator const& second) -> difference_type {
+            assert(first.container_ptr_ == second.container_ptr_);
+            return first.idx_ - second.idx_;
         }
 
+      private:
+        constexpr void advance(Idx n) { idx_ += n; }
+
         // store container pointer
         // and idx
         container_type* container_ptr_;

{power_grid_model-1.12.48 → power_grid_model-1.12.50}/tests/cpp_unit_tests/CMakeLists.txt

@@ -12,6 +12,7 @@ add_executable(power_grid_model_unit_tests_common
     "test_statistics.cpp"
     "test_three_phase_tensor.cpp"
     "test_typing.cpp"
+    "test_iterator_facade.cpp"
 )
 
 target_link_libraries(power_grid_model_unit_tests_common

power_grid_model-1.12.50/tests/cpp_unit_tests/test_iterator_facade.cpp

@@ -0,0 +1,201 @@
+// SPDX-FileCopyrightText: Contributors to the Power Grid Model project <powergridmodel@lfenergy.org>
+//
+// SPDX-License-Identifier: MPL-2.0
+
+#include <power_grid_model/common/counting_iterator.hpp>
+#include <power_grid_model/common/iterator_facade.hpp>
+
+#include <doctest/doctest.h>
+
+#include <optional>
+
+namespace {
+using power_grid_model::Idx;
+using power_grid_model::IdxRange;
+using power_grid_model::IdxVector;
+using power_grid_model::IntS;
+using power_grid_model::IteratorFacade;
+using power_grid_model::detail::iterator_facadeable_c;
+
+enum class IteratorFacadeableCalls : IntS {
+    none = 0,
+    dereference = 1,
+    advance = 2,
+    distance_to = 3,
+    increment = 4,
+    decrement = 5,
+};
+
+struct without_increment_decrement_t {};
+struct with_increment_decrement_t {};
+
+template <typename T>
+concept advance_type_c = std::same_as<T, without_increment_decrement_t> || std::same_as<T, with_increment_decrement_t>;
+
+template <advance_type_c advance_type_t, typename UnderlyingType> class BaseTestIterator : public IteratorFacade {
+    friend class IteratorFacade;
+
+  public:
+    using underlying = UnderlyingType;
+
+    using value_type = underlying::value_type;
+    using difference_type = underlying::difference_type;
+    using pointer = underlying::pointer;
+    using reference = underlying::reference;
+
+    static constexpr auto increment_style = std::same_as<advance_type_t, with_increment_decrement_t>
+                                                ? IteratorFacadeableCalls::increment
+                                                : IteratorFacadeableCalls::advance;
+    static constexpr auto decrement_style = std::same_as<advance_type_t, with_increment_decrement_t>
+                                                ? IteratorFacadeableCalls::decrement
+                                                : IteratorFacadeableCalls::advance;
+
+    constexpr BaseTestIterator(std::remove_cvref_t<underlying> it) : IteratorFacade{*this}, it_{std::move(it)} {}
+
+    constexpr auto operator*() -> reference {
+        last_call_ = IteratorFacadeableCalls::dereference;
+        return *it_;
+    }
+    constexpr auto operator*() const -> std::add_lvalue_reference_t<std::add_const_t<value_type>> {
+        last_call_ = IteratorFacadeableCalls::dereference;
+        return *it_;
+    }
+
+    friend constexpr auto operator<=>(BaseTestIterator const& first,
+                                      BaseTestIterator const& second) -> std::strong_ordering {
+        first.last_call_ = IteratorFacadeableCalls::distance_to;
+        return *first.it_ <=> *second.it_;
+    }
+
+    constexpr decltype(auto) operator+=(difference_type n) {
+        last_call_ = IteratorFacadeableCalls::advance;
+        it_ += n;
+        return *this;
+    }
+    friend constexpr auto operator-(BaseTestIterator const& first, BaseTestIterator const& second) -> difference_type {
+        first.last_call_ = IteratorFacadeableCalls::distance_to;
+        return first.it_ - second.it_;
+    }
+
+    constexpr std::optional<IteratorFacadeableCalls> const& last_call() const { return last_call_; }
+    constexpr void reset() { last_call_ = std::nullopt; }
+
+  private:
+    underlying it_;
+    mutable std::optional<IteratorFacadeableCalls> last_call_; // mutable to allow const methods to set it
+
+    constexpr void increment()
+        requires std::same_as<advance_type_t, with_increment_decrement_t>
+    {
+        last_call_ = IteratorFacadeableCalls::increment;
+        ++it_;
+    }
+    constexpr void decrement()
+        requires std::same_as<advance_type_t, with_increment_decrement_t>
+    {
+        last_call_ = IteratorFacadeableCalls::decrement;
+        --it_;
+    }
+};
+
+using TestIdxVectorIterator = BaseTestIterator<without_increment_decrement_t, typename IdxVector::iterator>;
+using TestIdxVectorConstIterator = BaseTestIterator<without_increment_decrement_t, typename IdxVector::const_iterator>;
+using TestIdxVectorIteratorWithIncDec = BaseTestIterator<with_increment_decrement_t, typename IdxVector::iterator>;
+using TestIdxVectorConstIteratorWithIncDec =
+    BaseTestIterator<with_increment_decrement_t, typename IdxVector::const_iterator>;
+
+static_assert(iterator_facadeable_c<TestIdxVectorIterator>);
+static_assert(iterator_facadeable_c<TestIdxVectorConstIterator>);
+static_assert(iterator_facadeable_c<TestIdxVectorIteratorWithIncDec>);
+static_assert(iterator_facadeable_c<TestIdxVectorConstIteratorWithIncDec>);
+
+static_assert(std::constructible_from<IteratorFacade, TestIdxVectorIterator>);
+static_assert(std::constructible_from<IteratorFacade, TestIdxVectorConstIterator>);
+static_assert(std::constructible_from<IteratorFacade, TestIdxVectorIteratorWithIncDec>);
+static_assert(std::constructible_from<IteratorFacade, TestIdxVectorConstIteratorWithIncDec>);
+
+} // namespace
+
+TYPE_TO_STRING_AS("TestIdxVectorIterator", TestIdxVectorIterator);
+TYPE_TO_STRING_AS("TestIdxVectorConstIterator", TestIdxVectorConstIterator);
+TYPE_TO_STRING_AS("TestIdxVectorIteratorWithIncDec", TestIdxVectorIteratorWithIncDec);
+TYPE_TO_STRING_AS("TestIdxVectorConstIteratorWithIncDec", TestIdxVectorConstIteratorWithIncDec);
+
+TEST_CASE_TEMPLATE("Test IteratorFacade", T, TestIdxVectorIterator, TestIdxVectorConstIterator,
+                   TestIdxVectorIteratorWithIncDec, TestIdxVectorConstIteratorWithIncDec) {
+    using TestIterator = T;
+
+    auto vec = IdxRange{40} | std::ranges::to<IdxVector>();
+
+    SUBCASE("Basic operations") {
+        auto it = TestIterator{vec.begin() + 5};
+        CHECK(*it == 5);
+        CHECK(*(++it) == 6);
+        CHECK(*(it++) == 6);
+        CHECK(*it == 7);
+        CHECK(*(--it) == 6);
+        CHECK(*(it--) == 6);
+        CHECK(*it == 5);
+        it += 3;
+        CHECK(*it == 8);
+        it -= 2;
+        CHECK(*it == 6);
+        it = it + 4;
+        CHECK(*it == 10);
+        it = 20 + it;
+        CHECK(*it == 30);
+        it = it - 5;
+        CHECK(*it == 25);
+
+        auto const it2 = TestIterator{vec.begin() + 25};
+        CHECK(it == it2);
+        CHECK((it <=> it2) == std::strong_ordering::equivalent);
+        auto const it3 = TestIterator{vec.begin() + 30};
+        CHECK((it <=> it3) == std::strong_ordering::less);
+        CHECK((it3 <=> it) == std::strong_ordering::greater);
+
+        auto dist = it2 - it;
+        CHECK(dist == 0);
+
+        auto const it4 = TestIterator{vec.begin() + 15};
+        dist = it2 - it4;
+        CHECK(dist == 10);
+        dist = it4 - it2;
+        CHECK(dist == -10);
+    }
+    if constexpr (std::is_same_v<TestIterator, TestIdxVectorIterator>) {
+        SUBCASE("Mutate elements") {
+            auto it = TestIterator{vec.begin() + 5};
+            *it = 42;
+            CHECK(*it == 42);
+            CHECK(vec[5] == 42);
+        }
+    }
+    SUBCASE("Incremented/Decremented calls") {
+        auto it = TestIterator{vec.begin() + 5};
+        REQUIRE(!it.last_call().has_value());
+
+        ++it;
+        REQUIRE(it.last_call().has_value());
+        CHECK(it.last_call().value() == TestIterator::increment_style);
+        it.reset();
+        REQUIRE(!it.last_call().has_value());
+
+        it++;
+        REQUIRE(it.last_call().has_value());
+        CHECK(it.last_call().value() == TestIterator::increment_style);
+        it.reset();
+        REQUIRE(!it.last_call().has_value());
+
+        --it;
+        REQUIRE(it.last_call().has_value());
+        CHECK(it.last_call().value() == TestIterator::decrement_style);
+        it.reset();
+        REQUIRE(!it.last_call().has_value());
+
+        it--;
+        REQUIRE(it.last_call().has_value());
+        CHECK(it.last_call().value() == TestIterator::decrement_style);
+        it.reset();
+    }
+}

power_grid_model-1.12.48/VERSION

@@ -1 +0,0 @@
-1.12.48