Second pass no except (#469)

Alex-PLACET · web-flow · commit 7865c47931b4 · 2025-06-27T08:56:04.000+02:00
diff --git a/include/sparrow/layout/array_base.hpp b/include/sparrow/layout/array_base.hpp
@@ -162,8 +162,8 @@ namespace sparrow
         constexpr array_crtp_base(array_crtp_base&&) noexcept = default;
         constexpr array_crtp_base& operator=(array_crtp_base&&) noexcept = default;
 
-        [[nodiscard]] constexpr arrow_proxy& get_arrow_proxy();
-        [[nodiscard]] constexpr const arrow_proxy& get_arrow_proxy() const;
+        [[nodiscard]] constexpr arrow_proxy& get_arrow_proxy() noexcept;
+        [[nodiscard]] constexpr const arrow_proxy& get_arrow_proxy() const noexcept;
 
         constexpr bitmap_const_reference has_value(size_type i) const;
 
@@ -391,13 +391,13 @@ namespace sparrow
     }
 
     template <class D>
-    constexpr auto array_crtp_base<D>::get_arrow_proxy() -> arrow_proxy&
+    constexpr auto array_crtp_base<D>::get_arrow_proxy() noexcept -> arrow_proxy&
     {
         return m_proxy;
     }
 
     template <class D>
-    constexpr auto array_crtp_base<D>::get_arrow_proxy() const -> const arrow_proxy&
+    constexpr auto array_crtp_base<D>::get_arrow_proxy() const noexcept -> const arrow_proxy&
     {
         return m_proxy;
     }
diff --git a/include/sparrow/layout/array_wrapper.hpp b/include/sparrow/layout/array_wrapper.hpp
@@ -47,7 +47,7 @@ namespace sparrow
         template <class ARRAY>
         struct get_data_type_from_array
         {
-            [[nodiscard]] static constexpr sparrow::data_type get()
+            [[nodiscard]] static constexpr sparrow::data_type get() noexcept
             {
                 return arrow_traits<typename ARRAY::inner_value_type>::type_id;
             }
@@ -56,7 +56,7 @@ namespace sparrow
         template <class ARRAY>
         struct is_dictionary_encoded_array
         {
-            [[nodiscard]] static constexpr bool get()
+            [[nodiscard]] static constexpr bool get() noexcept
             {
                 return false;
             }
@@ -80,7 +80,7 @@ namespace sparrow
 
         [[nodiscard]] wrapper_ptr clone() const;
 
-        [[nodiscard]] constexpr enum data_type data_type() const;
+        [[nodiscard]] constexpr enum data_type data_type() const noexcept;
         [[nodiscard]] constexpr bool is_dictionary() const;
 
         [[nodiscard]] constexpr arrow_proxy& get_arrow_proxy();
@@ -118,10 +118,10 @@ namespace sparrow
 
         using wrapper_ptr = array_wrapper::wrapper_ptr;
 
-        [[nodiscard]] constexpr enum data_type get_data_type() const;
+        [[nodiscard]] constexpr enum data_type get_data_type() const noexcept;
 
         constexpr array_wrapper_impl(const array_wrapper_impl&);
-        [[nodiscard]] constexpr bool is_dictionary_impl() const override;
+        [[nodiscard]] constexpr bool is_dictionary_impl() const noexcept override;
         [[nodiscard]] constexpr arrow_proxy& get_arrow_proxy_impl() override;
         [[nodiscard]] constexpr const arrow_proxy& get_arrow_proxy_impl() const override;
         [[nodiscard]] wrapper_ptr clone_impl() const override;
@@ -146,7 +146,7 @@ namespace sparrow
         return clone_impl();
     }
 
-    constexpr enum data_type array_wrapper::data_type() const
+    constexpr enum data_type array_wrapper::data_type() const noexcept
     {
         return m_data_type;
     }
@@ -212,7 +212,7 @@ namespace sparrow
     }
 
     template <class T>
-    constexpr enum data_type array_wrapper_impl<T>::get_data_type() const
+    constexpr enum data_type array_wrapper_impl<T>::get_data_type() const noexcept
     {
         return detail::get_data_type_from_array<T>::get();
     }
@@ -242,7 +242,7 @@ namespace sparrow
     }
 
     template <class T>
-    constexpr bool array_wrapper_impl<T>::is_dictionary_impl() const
+    constexpr bool array_wrapper_impl<T>::is_dictionary_impl() const noexcept
     {
         return detail::is_dictionary_encoded_array<T>::get();
     }
diff --git a/include/sparrow/layout/decimal_reference.hpp b/include/sparrow/layout/decimal_reference.hpp
@@ -40,11 +40,11 @@ namespace sparrow
         using size_type = typename L::size_type;
         using difference_type = std::ptrdiff_t;
 
-        constexpr decimal_reference(L* layout, size_type index);
+        constexpr decimal_reference(L* layout, size_type index) noexcept;
         constexpr decimal_reference(const decimal_reference&) = default;
         constexpr decimal_reference(decimal_reference&&) noexcept = default;
 
-        constexpr self_type& operator=(self_type&& rhs);
+        constexpr self_type& operator=(self_type&& rhs) noexcept;
         constexpr self_type& operator=(const self_type& rhs);
 
         constexpr self_type& operator=(value_type&& rhs);
@@ -78,7 +78,7 @@ namespace sparrow
      *************************************/
 
     template <typename L>
-    constexpr decimal_reference<L>::decimal_reference(L* layout, size_type index)
+    constexpr decimal_reference<L>::decimal_reference(L* layout, size_type index) noexcept
         : p_layout(layout)
         , m_index(index)
     {
@@ -99,7 +99,7 @@ namespace sparrow
     }
 
     template <typename L>
-    constexpr auto decimal_reference<L>::operator=(self_type&& rhs) -> self_type&
+    constexpr auto decimal_reference<L>::operator=(self_type&& rhs) noexcept -> self_type&
     {
         this->operator=(rhs.value());
         return *this;
diff --git a/include/sparrow/layout/dictionary_encoded_array.hpp b/include/sparrow/layout/dictionary_encoded_array.hpp
@@ -73,7 +73,7 @@ namespace sparrow
         template <std::integral IT>
         struct get_data_type_from_array<sparrow::dictionary_encoded_array<IT>>
         {
-            [[nodiscard]] static constexpr sparrow::data_type get()
+            [[nodiscard]] static constexpr sparrow::data_type get() noexcept
             {
                 return arrow_traits<typename primitive_array<IT>::inner_value_type>::type_id;
             }
@@ -82,7 +82,7 @@ namespace sparrow
         template <std::integral IT>
         struct is_dictionary_encoded_array<sparrow::dictionary_encoded_array<IT>>
         {
-            [[nodiscard]] static constexpr bool get()
+            [[nodiscard]] static constexpr bool get() noexcept
             {
                 return true;
             }
diff --git a/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp b/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_array.hpp
@@ -44,7 +44,7 @@ namespace sparrow
         template <>
         struct variable_size_binary_format<std::string, std::int32_t>
         {
-            [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format()
+            [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format() noexcept
             {
                 return "u";
             }
@@ -53,7 +53,7 @@ namespace sparrow
         template <>
         struct variable_size_binary_format<std::string, std::int64_t>
         {
-            [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format()
+            [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format() noexcept
             {
                 return "U";
             }
@@ -62,7 +62,7 @@ namespace sparrow
         template <>
         struct variable_size_binary_format<std::vector<byte_t>, std::int32_t>
         {
-            [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format()
+            [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format() noexcept
             {
                 return "z";
             }
@@ -71,7 +71,7 @@ namespace sparrow
         template <>
         struct variable_size_binary_format<std::vector<byte_t>, std::int64_t>
         {
-            [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format()
+            [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format() noexcept
             {
                 return "Z";
             }
@@ -138,7 +138,7 @@ namespace sparrow
         template <>
         struct get_data_type_from_array<sparrow::string_array>
         {
-            [[nodiscard]] static constexpr sparrow::data_type get()
+            [[nodiscard]] static constexpr sparrow::data_type get() noexcept
             {
                 return sparrow::data_type::STRING;
             }
@@ -147,7 +147,7 @@ namespace sparrow
         template <>
         struct get_data_type_from_array<sparrow::big_string_array>
         {
-            [[nodiscard]] static constexpr sparrow::data_type get()
+            [[nodiscard]] static constexpr sparrow::data_type get() noexcept
             {
                 return sparrow::data_type::LARGE_STRING;
             }
@@ -156,7 +156,7 @@ namespace sparrow
         template <>
         struct get_data_type_from_array<sparrow::binary_array>
         {
-            [[nodiscard]] static constexpr sparrow::data_type get()
+            [[nodiscard]] static constexpr sparrow::data_type get() noexcept
             {
                 return sparrow::data_type::BINARY;
             }
@@ -165,7 +165,7 @@ namespace sparrow
         template <>
         struct get_data_type_from_array<sparrow::big_binary_array>
         {
-            [[nodiscard]] static constexpr sparrow::data_type get()
+            [[nodiscard]] static constexpr sparrow::data_type get() noexcept
             {
                 return sparrow::data_type::LARGE_BINARY;
             }
diff --git a/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_iterator.hpp b/include/sparrow/layout/variable_size_binary_layout/variable_size_binary_iterator.hpp
@@ -55,12 +55,12 @@ namespace sparrow
 
         [[nodiscard]] constexpr reference dereference() const;
 
-        constexpr void increment();
-        constexpr void decrement();
-        constexpr void advance(difference_type n);
-        [[nodiscard]] constexpr difference_type distance_to(const self_type& rhs) const;
-        [[nodiscard]] constexpr bool equal(const self_type& rhs) const;
-        [[nodiscard]] constexpr bool less_than(const self_type& rhs) const;
+        constexpr void increment() noexcept;
+        constexpr void decrement() noexcept;
+        constexpr void advance(difference_type n) noexcept;
+        [[nodiscard]] constexpr difference_type distance_to(const self_type& rhs) const noexcept;
+        [[nodiscard]] constexpr bool equal(const self_type& rhs) const noexcept;
+        [[nodiscard]] constexpr bool less_than(const self_type& rhs) const noexcept;
 
         layout_type* p_layout = nullptr;
         difference_type m_index;
@@ -96,40 +96,42 @@ namespace sparrow
     }
 
     template <class Layout, iterator_types Iterator_types>
-    constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::increment()
+    constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::increment() noexcept
     {
         ++m_index;
     }
 
     template <class Layout, iterator_types Iterator_types>
-    constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::decrement()
+    constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::decrement() noexcept
     {
         --m_index;
     }
 
     template <class Layout, iterator_types Iterator_types>
-    constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::advance(difference_type n)
+    constexpr void
+    variable_size_binary_value_iterator<Layout, Iterator_types>::advance(difference_type n) noexcept
     {
         m_index += n;
     }
 
     template <class Layout, iterator_types Iterator_types>
     constexpr auto
-    variable_size_binary_value_iterator<Layout, Iterator_types>::distance_to(const self_type& rhs) const
+    variable_size_binary_value_iterator<Layout, Iterator_types>::distance_to(const self_type& rhs) const noexcept
         -> difference_type
     {
         return rhs.m_index - m_index;
     }
 
     template <class Layout, iterator_types Iterator_types>
-    constexpr bool variable_size_binary_value_iterator<Layout, Iterator_types>::equal(const self_type& rhs) const
+    constexpr bool
+    variable_size_binary_value_iterator<Layout, Iterator_types>::equal(const self_type& rhs) const noexcept
     {
         return (p_layout == rhs.p_layout) && (m_index == rhs.m_index);
     }
 
     template <class Layout, iterator_types Iterator_types>
     constexpr bool
-    variable_size_binary_value_iterator<Layout, Iterator_types>::less_than(const self_type& rhs) const
+    variable_size_binary_value_iterator<Layout, Iterator_types>::less_than(const self_type& rhs) const noexcept
     {
         return (p_layout == rhs.p_layout) && (m_index < rhs.m_index);
     }

Original file line number	Diff line number	Diff line change
`@@ -162,8 +162,8 @@ namespace sparrow`
`162`	`162`	`constexpr array_crtp_base(array_crtp_base&&) noexcept = default;`
`163`	`163`	`constexpr array_crtp_base& operator=(array_crtp_base&&) noexcept = default;`
`164`	`164`
`165`		`- [[nodiscard]] constexpr arrow_proxy& get_arrow_proxy();`
`166`		`- [[nodiscard]] constexpr const arrow_proxy& get_arrow_proxy() const;`
	`165`	`+ [[nodiscard]] constexpr arrow_proxy& get_arrow_proxy() noexcept;`
	`166`	`+ [[nodiscard]] constexpr const arrow_proxy& get_arrow_proxy() const noexcept;`
`167`	`167`
`168`	`168`	`constexpr bitmap_const_reference has_value(size_type i) const;`
`169`	`169`
`@@ -391,13 +391,13 @@ namespace sparrow`
`391`	`391`	`}`
`392`	`392`
`393`	`393`	`template <class D>`
`394`		`- constexpr auto array_crtp_base<D>::get_arrow_proxy() -> arrow_proxy&`
	`394`	`+ constexpr auto array_crtp_base<D>::get_arrow_proxy() noexcept -> arrow_proxy&`
`395`	`395`	`{`
`396`	`396`	`return m_proxy;`
`397`	`397`	`}`
`398`	`398`
`399`	`399`	`template <class D>`
`400`		`- constexpr auto array_crtp_base<D>::get_arrow_proxy() const -> const arrow_proxy&`
	`400`	`+ constexpr auto array_crtp_base<D>::get_arrow_proxy() const noexcept -> const arrow_proxy&`
`401`	`401`	`{`
`402`	`402`	`return m_proxy;`
`403`	`403`	`}`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ namespace sparrow`
`47`	`47`	`template <class ARRAY>`
`48`	`48`	`struct get_data_type_from_array`
`49`	`49`	`{`
`50`		`- [[nodiscard]] static constexpr sparrow::data_type get()`
	`50`	`+ [[nodiscard]] static constexpr sparrow::data_type get() noexcept`
`51`	`51`	`{`
`52`	`52`	`return arrow_traits<typename ARRAY::inner_value_type>::type_id;`
`53`	`53`	`}`
`@@ -56,7 +56,7 @@ namespace sparrow`
`56`	`56`	`template <class ARRAY>`
`57`	`57`	`struct is_dictionary_encoded_array`
`58`	`58`	`{`
`59`		`- [[nodiscard]] static constexpr bool get()`
	`59`	`+ [[nodiscard]] static constexpr bool get() noexcept`
`60`	`60`	`{`
`61`	`61`	`return false;`
`62`	`62`	`}`
`@@ -80,7 +80,7 @@ namespace sparrow`
`80`	`80`
`81`	`81`	`[[nodiscard]] wrapper_ptr clone() const;`
`82`	`82`
`83`		`- [[nodiscard]] constexpr enum data_type data_type() const;`
	`83`	`+ [[nodiscard]] constexpr enum data_type data_type() const noexcept;`
`84`	`84`	`[[nodiscard]] constexpr bool is_dictionary() const;`
`85`	`85`
`86`	`86`	`[[nodiscard]] constexpr arrow_proxy& get_arrow_proxy();`
`@@ -118,10 +118,10 @@ namespace sparrow`
`118`	`118`
`119`	`119`	`using wrapper_ptr = array_wrapper::wrapper_ptr;`
`120`	`120`
`121`		`- [[nodiscard]] constexpr enum data_type get_data_type() const;`
	`121`	`+ [[nodiscard]] constexpr enum data_type get_data_type() const noexcept;`
`122`	`122`
`123`	`123`	`constexpr array_wrapper_impl(const array_wrapper_impl&);`
`124`		`- [[nodiscard]] constexpr bool is_dictionary_impl() const override;`
	`124`	`+ [[nodiscard]] constexpr bool is_dictionary_impl() const noexcept override;`
`125`	`125`	`[[nodiscard]] constexpr arrow_proxy& get_arrow_proxy_impl() override;`
`126`	`126`	`[[nodiscard]] constexpr const arrow_proxy& get_arrow_proxy_impl() const override;`
`127`	`127`	`[[nodiscard]] wrapper_ptr clone_impl() const override;`
`@@ -146,7 +146,7 @@ namespace sparrow`
`146`	`146`	`return clone_impl();`
`147`	`147`	`}`
`148`	`148`
`149`		`- constexpr enum data_type array_wrapper::data_type() const`
	`149`	`+ constexpr enum data_type array_wrapper::data_type() const noexcept`
`150`	`150`	`{`
`151`	`151`	`return m_data_type;`
`152`	`152`	`}`
`@@ -212,7 +212,7 @@ namespace sparrow`
`212`	`212`	`}`
`213`	`213`
`214`	`214`	`template <class T>`
`215`		`- constexpr enum data_type array_wrapper_impl<T>::get_data_type() const`
	`215`	`+ constexpr enum data_type array_wrapper_impl<T>::get_data_type() const noexcept`
`216`	`216`	`{`
`217`	`217`	`return detail::get_data_type_from_array<T>::get();`
`218`	`218`	`}`
`@@ -242,7 +242,7 @@ namespace sparrow`
`242`	`242`	`}`
`243`	`243`
`244`	`244`	`template <class T>`
`245`		`- constexpr bool array_wrapper_impl<T>::is_dictionary_impl() const`
	`245`	`+ constexpr bool array_wrapper_impl<T>::is_dictionary_impl() const noexcept`
`246`	`246`	`{`
`247`	`247`	`return detail::is_dictionary_encoded_array<T>::get();`
`248`	`248`	`}`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ namespace sparrow`
`73`	`73`	`template <std::integral IT>`
`74`	`74`	`struct get_data_type_from_array<sparrow::dictionary_encoded_array<IT>>`
`75`	`75`	`{`
`76`		`- [[nodiscard]] static constexpr sparrow::data_type get()`
	`76`	`+ [[nodiscard]] static constexpr sparrow::data_type get() noexcept`
`77`	`77`	`{`
`78`	`78`	`return arrow_traits<typename primitive_array<IT>::inner_value_type>::type_id;`
`79`	`79`	`}`
`@@ -82,7 +82,7 @@ namespace sparrow`
`82`	`82`	`template <std::integral IT>`
`83`	`83`	`struct is_dictionary_encoded_array<sparrow::dictionary_encoded_array<IT>>`
`84`	`84`	`{`
`85`		`- [[nodiscard]] static constexpr bool get()`
	`85`	`+ [[nodiscard]] static constexpr bool get() noexcept`
`86`	`86`	`{`
`87`	`87`	`return true;`
`88`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,7 @@ namespace sparrow`
`44`	`44`	`template <>`
`45`	`45`	`struct variable_size_binary_format<std::string, std::int32_t>`
`46`	`46`	`{`
`47`		`- [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format()`
	`47`	`+ [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format() noexcept`
`48`	`48`	`{`
`49`	`49`	`return "u";`
`50`	`50`	`}`
`@@ -53,7 +53,7 @@ namespace sparrow`
`53`	`53`	`template <>`
`54`	`54`	`struct variable_size_binary_format<std::string, std::int64_t>`
`55`	`55`	`{`
`56`		`- [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format()`
	`56`	`+ [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format() noexcept`
`57`	`57`	`{`
`58`	`58`	`return "U";`
`59`	`59`	`}`
`@@ -62,7 +62,7 @@ namespace sparrow`
`62`	`62`	`template <>`
`63`	`63`	`struct variable_size_binary_format<std::vector<byte_t>, std::int32_t>`
`64`	`64`	`{`
`65`		`- [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format()`
	`65`	`+ [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format() noexcept`
`66`	`66`	`{`
`67`	`67`	`return "z";`
`68`	`68`	`}`
`@@ -71,7 +71,7 @@ namespace sparrow`
`71`	`71`	`template <>`
`72`	`72`	`struct variable_size_binary_format<std::vector<byte_t>, std::int64_t>`
`73`	`73`	`{`
`74`		`- [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format()`
	`74`	`+ [[nodiscard]] static SPARROW_CONSTEXPR_GCC_11 std::string format() noexcept`
`75`	`75`	`{`
`76`	`76`	`return "Z";`
`77`	`77`	`}`
`@@ -138,7 +138,7 @@ namespace sparrow`
`138`	`138`	`template <>`
`139`	`139`	`struct get_data_type_from_array<sparrow::string_array>`
`140`	`140`	`{`
`141`		`- [[nodiscard]] static constexpr sparrow::data_type get()`
	`141`	`+ [[nodiscard]] static constexpr sparrow::data_type get() noexcept`
`142`	`142`	`{`
`143`	`143`	`return sparrow::data_type::STRING;`
`144`	`144`	`}`
`@@ -147,7 +147,7 @@ namespace sparrow`
`147`	`147`	`template <>`
`148`	`148`	`struct get_data_type_from_array<sparrow::big_string_array>`
`149`	`149`	`{`
`150`		`- [[nodiscard]] static constexpr sparrow::data_type get()`
	`150`	`+ [[nodiscard]] static constexpr sparrow::data_type get() noexcept`
`151`	`151`	`{`
`152`	`152`	`return sparrow::data_type::LARGE_STRING;`
`153`	`153`	`}`
`@@ -156,7 +156,7 @@ namespace sparrow`
`156`	`156`	`template <>`
`157`	`157`	`struct get_data_type_from_array<sparrow::binary_array>`
`158`	`158`	`{`
`159`		`- [[nodiscard]] static constexpr sparrow::data_type get()`
	`159`	`+ [[nodiscard]] static constexpr sparrow::data_type get() noexcept`
`160`	`160`	`{`
`161`	`161`	`return sparrow::data_type::BINARY;`
`162`	`162`	`}`
`@@ -165,7 +165,7 @@ namespace sparrow`
`165`	`165`	`template <>`
`166`	`166`	`struct get_data_type_from_array<sparrow::big_binary_array>`
`167`	`167`	`{`
`168`		`- [[nodiscard]] static constexpr sparrow::data_type get()`
	`168`	`+ [[nodiscard]] static constexpr sparrow::data_type get() noexcept`
`169`	`169`	`{`
`170`	`170`	`return sparrow::data_type::LARGE_BINARY;`
`171`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,12 +55,12 @@ namespace sparrow`
`55`	`55`
`56`	`56`	`[[nodiscard]] constexpr reference dereference() const;`
`57`	`57`
`58`		`- constexpr void increment();`
`59`		`- constexpr void decrement();`
`60`		`- constexpr void advance(difference_type n);`
`61`		`- [[nodiscard]] constexpr difference_type distance_to(const self_type& rhs) const;`
`62`		`- [[nodiscard]] constexpr bool equal(const self_type& rhs) const;`
`63`		`- [[nodiscard]] constexpr bool less_than(const self_type& rhs) const;`
	`58`	`+ constexpr void increment() noexcept;`
	`59`	`+ constexpr void decrement() noexcept;`
	`60`	`+ constexpr void advance(difference_type n) noexcept;`
	`61`	`+ [[nodiscard]] constexpr difference_type distance_to(const self_type& rhs) const noexcept;`
	`62`	`+ [[nodiscard]] constexpr bool equal(const self_type& rhs) const noexcept;`
	`63`	`+ [[nodiscard]] constexpr bool less_than(const self_type& rhs) const noexcept;`
`64`	`64`
`65`	`65`	`layout_type* p_layout = nullptr;`
`66`	`66`	`difference_type m_index;`
`@@ -96,40 +96,42 @@ namespace sparrow`
`96`	`96`	`}`
`97`	`97`
`98`	`98`	`template <class Layout, iterator_types Iterator_types>`
`99`		`- constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::increment()`
	`99`	`+ constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::increment() noexcept`
`100`	`100`	`{`
`101`	`101`	`++m_index;`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`template <class Layout, iterator_types Iterator_types>`
`105`		`- constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::decrement()`
	`105`	`+ constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::decrement() noexcept`
`106`	`106`	`{`
`107`	`107`	`--m_index;`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`template <class Layout, iterator_types Iterator_types>`
`111`		`- constexpr void variable_size_binary_value_iterator<Layout, Iterator_types>::advance(difference_type n)`
	`111`	`+ constexpr void`
	`112`	`+ variable_size_binary_value_iterator<Layout, Iterator_types>::advance(difference_type n) noexcept`
`112`	`113`	`{`
`113`	`114`	`m_index += n;`
`114`	`115`	`}`
`115`	`116`
`116`	`117`	`template <class Layout, iterator_types Iterator_types>`
`117`	`118`	`constexpr auto`
`118`		`- variable_size_binary_value_iterator<Layout, Iterator_types>::distance_to(const self_type& rhs) const`
	`119`	`+ variable_size_binary_value_iterator<Layout, Iterator_types>::distance_to(const self_type& rhs) const noexcept`
`119`	`120`	`-> difference_type`
`120`	`121`	`{`
`121`	`122`	`return rhs.m_index - m_index;`
`122`	`123`	`}`
`123`	`124`
`124`	`125`	`template <class Layout, iterator_types Iterator_types>`
`125`		`- constexpr bool variable_size_binary_value_iterator<Layout, Iterator_types>::equal(const self_type& rhs) const`
	`126`	`+ constexpr bool`
	`127`	`+ variable_size_binary_value_iterator<Layout, Iterator_types>::equal(const self_type& rhs) const noexcept`
`126`	`128`	`{`
`127`	`129`	`return (p_layout == rhs.p_layout) && (m_index == rhs.m_index);`
`128`	`130`	`}`
`129`	`131`
`130`	`132`	`template <class Layout, iterator_types Iterator_types>`
`131`	`133`	`constexpr bool`
`132`		`- variable_size_binary_value_iterator<Layout, Iterator_types>::less_than(const self_type& rhs) const`
	`134`	`+ variable_size_binary_value_iterator<Layout, Iterator_types>::less_than(const self_type& rhs) const noexcept`
`133`	`135`	`{`
`134`	`136`	`return (p_layout == rhs.p_layout) && (m_index < rhs.m_index);`
`135`	`137`	`}`