to_diff

Author: SpectraL519

include/gl/impl/specialized/adjacency_list.hpp

@@ -154,7 +154,7 @@ struct directed_adjacency_list {
         }
 
         // remove the list of edges incident from the vertex entirely
-        self._list.erase(self._list.begin() + static_cast<std::ptrdiff_t>(vertex_id));
+        self._list.erase(self._list.begin() + to_diff(vertex_id));
         return removed_edges;
     }
 
@@ -255,7 +255,7 @@ struct undirected_adjacency_list {
         const auto removed_edges =
             self._list[vertex_idx] | std::views::transform(&item_type::edge_id)
             | std::ranges::to<std::vector>();
-        self._list.erase(self._list.begin() + static_cast<std::ptrdiff_t>(vertex_id));
+        self._list.erase(self._list.begin() + to_diff(vertex_id));
         return removed_edges;
     }
 

include/gl/impl/specialized/adjacency_matrix.hpp

@@ -154,12 +154,12 @@ struct directed_adjacency_matrix {
             | std::views::filter([](auto edge_id) { return edge_id != invalid_id; })
             | std::ranges::to<std::vector>();
 
-        self._matrix.erase(self._matrix.begin() + static_cast<std::ptrdiff_t>(vertex_id));
-
+        const auto vertex_pos = to_diff(vertex_id);
+        self._matrix.erase(self._matrix.begin() + vertex_pos);
         for (auto& row : self._matrix) {
             if (const auto edge_id = row[vertex_idx]; edge_id != invalid_id)
                 removed_edges.push_back(edge_id);
-            row.erase(row.begin() + static_cast<std::ptrdiff_t>(vertex_id));
+            row.erase(row.begin() + vertex_pos);
         }
 
         return removed_edges;
@@ -281,7 +281,7 @@ struct undirected_adjacency_matrix {
             | std::views::filter([](auto edge_id) { return edge_id != invalid_id; })
             | std::ranges::to<std::vector>();
 
-        const auto vertex_pos = static_cast<std::ptrdiff_t>(vertex_id);
+        const auto vertex_pos = to_diff(vertex_id);
         self._matrix.erase(self._matrix.begin() + vertex_pos);
         for (auto& row : self._matrix)
             row.erase(row.begin() + vertex_pos);

include/gl/types/core.hpp

@@ -28,7 +28,6 @@ concept c_id_type = std::unsigned_integral<T>;
     return static_cast<size_type>(id);
 }
 
-// TODO: replace static_cast calls with to_diff
 [[nodiscard]] gl_attr_force_inline constexpr std::ptrdiff_t to_diff(std::integral auto i) noexcept {
     return static_cast<std::ptrdiff_t>(i);
 }

include/gl/types/flat_jagged_vector.hpp

@@ -54,7 +54,7 @@ class flat_jagged_vector {
 
     /// @brief Random access iterator over segments of the `flat_jagged_vector`.
     ///
-    /// This iterator dereferences to a `segment_type` (span of elements in a single segment),
+    /// This iterator dereferences to a `segment_type` (subrange of elements in a single segment),
     /// allowing efficient iteration and random access to individual segments. The iterator maintains
     /// pointers to the element data and the offsets array for dereferencing.
     ///
@@ -74,13 +74,13 @@ class flat_jagged_vector {
         using iterator_concept = std::random_access_iterator_tag;
         /// @brief Legacy iterator category (random access)
         using iterator_category = std::random_access_iterator_tag;
-        /// @brief Type of segment this iterator dereferences to (span or const span)
+        /// @brief Type of segment this iterator dereferences to (subrange or const subrange)
         using value_type = std::conditional_t<Const, const_segment_type, segment_type>;
         /// @brief Signed integral difference type
         using difference_type = std::ptrdiff_t;
-        /// @brief Pointer type (void because segment iterators dereference to spans)
+        /// @brief Pointer type (void because segment iterators dereference to subranges)
         using pointer = void;
-        /// @brief Reference type (span of elements)
+        /// @brief Reference type (subrange of elements)
         using reference = value_type;
 
         /// @brief Default constructor creates a null iterator
@@ -101,7 +101,7 @@ class flat_jagged_vector {
         }
 
         /// @brief Dereferences the iterator to the current segment.
-        /// @return A span representing the segment at the current position
+        /// @return A subrange representing the segment at the current position
         [[nodiscard]] reference operator*() const noexcept {
             const auto beg = to_diff(*this->_offset_ptr);
             const auto end = to_diff(*(this->_offset_ptr + 1uz));
@@ -472,7 +472,7 @@ class flat_jagged_vector {
 
     /// @brief Returns the segment at the given index without bounds checking.
     /// @param i The index of the segment to access
-    /// @return A span representing the segment at index i
+    /// @return A subrange representing the segment at index i
     /// @pre `i < size()`; otherwise Undefined Behavior
     /// @warning No bounds checking is performed for performance. Use `at()` for bounds-checked access.
     ///          Calling on an out-of-bounds index results in Undefined Behavior.
@@ -484,7 +484,7 @@ class flat_jagged_vector {
 
     /// @brief Returns a const segment at the given index without bounds checking.
     /// @param i The index of the segment to access
-    /// @return A const span representing the segment at index i
+    /// @return A const subrange representing the segment at index i
     /// @pre `i < size()`; otherwise Undefined Behavior
     /// @warning No bounds checking is performed for performance. Use `at()` for bounds-checked access.
     ///          Calling on an out-of-bounds index results in Undefined Behavior.
@@ -518,7 +518,7 @@ class flat_jagged_vector {
 
     /// @brief Returns the segment at the given index with bounds checking.
     /// @param i The index of the segment
-    /// @return A span representing the segment at index i
+    /// @return A subrange representing the segment at index i
     /// @exception std::out_of_range If `i >= size()`
     /// @note Provides the same safety as `std::vector::at()`
     [[nodiscard]] segment_type at(size_type i) {
@@ -528,7 +528,7 @@ class flat_jagged_vector {
 
     /// @brief Returns a const segment at the given index with bounds checking.
     /// @param i The index of the segment
-    /// @return A const span representing the segment at index i
+    /// @return A const subrange representing the segment at index i
     /// @exception std::out_of_range If `i >= size()`
     /// @note Provides the same safety as `std::vector::at()`
     [[nodiscard]] const_segment_type at(size_type i) const {
@@ -561,31 +561,31 @@ class flat_jagged_vector {
     }
 
     /// @brief Returns the first segment without bounds checking.
-    /// @return A span representing the first segment
+    /// @return A subrange representing the first segment
     /// @pre Container must not be empty; otherwise Undefined Behavior
     /// @warning No bounds checking. Results in Undefined Behavior if container is empty.
     [[nodiscard]] segment_type front() noexcept {
         return (*this)[0uz];
     }
 
     /// @brief Returns a const reference to the first segment without bounds checking.
-    /// @return A const span representing the first segment
+    /// @return A const subrange representing the first segment
     /// @pre Container must not be empty; otherwise Undefined Behavior
     /// @warning No bounds checking. Results in Undefined Behavior if container is empty.
     [[nodiscard]] const_segment_type front() const noexcept {
         return (*this)[0uz];
     }
 
     /// @brief Returns the last segment without bounds checking.
-    /// @return A span representing the last segment
+    /// @return A subrange representing the last segment
     /// @pre Container must not be empty; otherwise Undefined Behavior
     /// @warning No bounds checking. Results in Undefined Behavior if container is empty.
     [[nodiscard]] segment_type back() noexcept {
         return (*this)[this->size() - 1uz];
     }
 
     /// @brief Returns a const reference to the last segment without bounds checking.
-    /// @return A const span representing the last segment
+    /// @return A const subrange representing the last segment
     /// @pre Container must not be empty; otherwise Undefined Behavior
     /// @warning No bounds checking. Results in Undefined Behavior if container is empty.
     [[nodiscard]] const_segment_type back() const noexcept {
@@ -670,15 +670,15 @@ class flat_jagged_vector {
         return this->_data.size();
     }
 
-    /// @brief Returns a span over all element data in flattened form.
-    /// @return A span of all elements in the underlying `_data` array.
+    /// @brief Returns a subrange of all element data in flattened form.
+    /// @return A subrange of all elements in the underlying `_data` array.
     /// @note Allows direct access to the flattened representation of all segments.
     [[nodiscard]] segment_type data_view() noexcept {
         return segment_type(this->_data);
     }
 
-    /// @brief Returns a const span over all element data in flattened form.
-    /// @return A const span of all elements in the underlying `_data` array.
+    /// @brief Returns a const subrange of all element data in flattened form.
+    /// @return A const subrange of all elements in the underlying `_data` array.
     /// @note Allows direct access to the flattened representation of all segments.
     [[nodiscard]] const_segment_type data_view() const noexcept {
         return const_segment_type(this->_data);

include/hgl/impl/incidence_list.hpp

@@ -169,9 +169,7 @@ class incidence_list<hgl::undirected_t, ImplTag> final {
     template <element_type Element>
     void _remove(const id_type id) noexcept {
         if constexpr (Element == layout_tag::major_element) { // remove major
-            this->_major_storage.erase(
-                this->_major_storage.begin() + static_cast<std::ptrdiff_t>(id)
-            );
+            this->_major_storage.erase(this->_major_storage.begin() + to_diff(id));
         }
         else { // remove minor
             for (auto& minor_storage : this->_major_storage) {
@@ -449,12 +447,8 @@ class incidence_list<hgl::bf_directed_t, ImplTag> final {
     template <element_type Element>
     void _remove(const id_type id) noexcept {
         if constexpr (Element == layout_tag::major_element) { // remove major
-            this->_tail_storage.erase(
-                this->_tail_storage.begin() + static_cast<std::ptrdiff_t>(id)
-            );
-            this->_head_storage.erase(
-                this->_head_storage.begin() + static_cast<std::ptrdiff_t>(id)
-            );
+            this->_tail_storage.erase(this->_tail_storage.begin() + to_diff(id));
+            this->_head_storage.erase(this->_head_storage.begin() + to_diff(id));
         }
         else { // remove minor
             for (auto& minor_storage : this->_tail_storage)

include/hgl/impl/incidence_matrix.hpp

@@ -166,14 +166,14 @@ class incidence_matrix<hgl::undirected_t, ImplTag> final {
     template <element_type Element>
     void _remove(const id_type id) noexcept {
         if constexpr (Element == layout_tag::major_element) { // remove major
-            this->_matrix.erase(this->_matrix.begin() + static_cast<std::ptrdiff_t>(id));
+            this->_matrix.erase(this->_matrix.begin() + to_diff(id));
         }
         else { // remove minor
             if (this->_matrix_row_size == 0uz)
                 return;
             this->_matrix_row_size--;
             for (auto& row : this->_matrix) {
-                row.erase(row.begin() + static_cast<std::ptrdiff_t>(id));
+                row.erase(row.begin() + to_diff(id));
             }
         }
     }
@@ -464,14 +464,14 @@ class incidence_matrix<hgl::bf_directed_t, ImplTag> final {
     template <element_type Element>
     void _remove(const id_type id) noexcept {
         if constexpr (Element == layout_tag::major_element) { // remove major
-            this->_matrix.erase(this->_matrix.begin() + static_cast<std::ptrdiff_t>(id));
+            this->_matrix.erase(this->_matrix.begin() + to_diff(id));
         }
         else { // remove minor
             if (this->_matrix_row_size == 0uz)
                 return;
             this->_matrix_row_size--;
             for (auto& row : this->_matrix)
-                row.erase(row.begin() + static_cast<std::ptrdiff_t>(id));
+                row.erase(row.begin() + to_diff(id));
         }
     }
 

tests/source/gl/test_graph_topology_builders.cpp

@@ -285,7 +285,7 @@ TEST_CASE_TEMPLATE_DEFINE(
     SUBCASE("path(n_vertices) should build a one-way path graph of size n_vertices") {
         const auto path = gl::topology::path<graph_type>(constants::n_elements_top);
         const auto n_source_vertices = path.order() - 1uz;
-        const auto last_vertex_pos = static_cast<std::ptrdiff_t>(n_source_vertices);
+        const auto last_vertex_pos = gl::to_diff(n_source_vertices);
 
         verify_graph_size(path, constants::n_elements_top, n_source_vertices);
 
@@ -299,7 +299,7 @@ TEST_CASE_TEMPLATE_DEFINE(
     SUBCASE("bidirectional_path(n_vertices) should build a two-way path graph of size n_vertices") {
         const auto path = gl::topology::bidirectional_path<graph_type>(constants::n_elements_top);
         const auto n_source_vertices = path.order() - 1uz;
-        const auto last_vertex_pos = static_cast<std::ptrdiff_t>(n_source_vertices);
+        const auto last_vertex_pos = gl::to_diff(n_source_vertices);
 
         verify_graph_size(path, constants::n_elements_top, 2uz * n_source_vertices);
 
@@ -389,7 +389,7 @@ TEST_CASE_TEMPLATE_DEFINE(
         CAPTURE(path);
 
         const auto n_source_vertices = path.order() - 1uz;
-        const auto last_vertex_pos = static_cast<std::ptrdiff_t>(n_source_vertices);
+        const auto last_vertex_pos = gl::to_diff(n_source_vertices);
         verify_graph_size(path, constants::n_elements_top, n_source_vertices);
 
         const auto vertices = path.vertices();