flat_jagged vector alignment

Author: SpectraL519

include/gl/types/flat_jagged_vector.hpp

@@ -13,11 +13,6 @@
 #include <stdexcept>
 #include <vector>
 
-// TODO:
-// - use std::ranges::subrange instead of std::span
-// - define container_type
-// - use std::ptrdiff_t for offsets
-
 namespace gl {
 
 /// @brief A flattened 2D vector (jagged array) providing efficient storage for variable-length segments.
@@ -34,21 +29,24 @@ namespace gl {
 /// @todo Implement assign, and swap methods.
 /// @todo Implement iterator-based insert, emplace and erase methods.
 /// @todo Add `operator<<` overload for `std::ostream` and specialize `std::formatter`.
+/// @todo Use std::ptrdiff_t instead of std::size_t for offset values
 template <std::semiregular T>
 class flat_jagged_vector {
 public:
     /// @brief Type of elements stored in segments
     using value_type = T;
     /// @brief Unsigned integral type used for sizes and indices
     using size_type = std::size_t;
+    /// @brief The underlying contiguous storage container
+    using container_type = std::vector<value_type>;
     /// @brief Reference to an element
-    using reference = value_type&;
+    using reference = typename container_type::reference;
     /// @brief Const reference to an element
-    using const_reference = const value_type&;
-    /// @brief Span type representing a non-owning segment of elements
-    using segment_type = std::span<value_type>;
-    /// @brief Const span type representing a non-owning const segment of elements
-    using const_segment_type = std::span<const value_type>;
+    using const_reference = typename container_type::const_reference;
+    /// @brief Subrange type representing a non-owning segment of elements
+    using segment_type = std::ranges::subrange<typename container_type::iterator>;
+    /// @brief Const subrange type representing a non-owning const segment of elements
+    using const_segment_type = std::ranges::subrange<typename container_type::const_iterator>;
 
     // --- iterators ---
 
@@ -63,7 +61,10 @@ class flat_jagged_vector {
     /// @warning Invalidated when the `flat_jagged_vector` is modified (structure changes or element insertions/deletions).
     template <bool Const>
     class segment_iterator {
-        using data_ptr_type = std::conditional_t<Const, const T*, T*>;
+        using data_iter_type = std::conditional_t<
+            Const,
+            typename container_type::const_iterator,
+            typename container_type::iterator>;
         using offset_ptr_type = const size_type*;
 
     public:
@@ -84,25 +85,25 @@ class flat_jagged_vector {
         segment_iterator() = default;
 
         /// @brief Constructs an iterator pointing to a specific segment.
-        /// @param data_ptr Pointer to the underlying element data (may be null for null iterator)
+        /// @param data_iter Iterator to the underlying element data (may be null for null iterator)
         /// @param offset_ptr Pointer to the offsets array at the position of this segment
-        segment_iterator(data_ptr_type data_ptr, offset_ptr_type offset_ptr) noexcept
-        : _data_ptr(data_ptr), _offset_ptr(offset_ptr) {}
+        segment_iterator(data_iter_type data_iter, offset_ptr_type offset_ptr) noexcept
+        : _data_iter(data_iter), _offset_ptr(offset_ptr) {}
 
         /// @brief Implicit conversion from mutable to const iterator
         /// @return A const iterator pointing to the same segment
         operator segment_iterator<true>() const noexcept
         requires(not Const)
         {
-            return segment_iterator<true>(this->_data_ptr, this->_offset_ptr);
+            return segment_iterator<true>(this->_data_iter, this->_offset_ptr);
         }
 
         /// @brief Dereferences the iterator to the current segment.
         /// @return A span representing the segment at the current position
         [[nodiscard]] reference operator*() const noexcept {
             const auto beg = *this->_offset_ptr;
             const auto end = *(this->_offset_ptr + 1uz);
-            return reference(this->_data_ptr + beg, end - beg);
+            return reference(this->_data_iter + beg, this->_data_iter + end);
         }
 
         /// @brief Random access to a segment at offset from current position.
@@ -220,7 +221,7 @@ class flat_jagged_vector {
         }
 
     private:
-        data_ptr_type _data_ptr{nullptr};
+        data_iter_type _data_iter;
         offset_ptr_type _offset_ptr{nullptr};
     };
 
@@ -476,7 +477,7 @@ class flat_jagged_vector {
     [[nodiscard]] segment_type operator[](size_type i) {
         const auto beg = this->_offsets[i];
         const auto end = this->_offsets[i + 1uz];
-        return segment_type(this->_data.data() + beg, end - beg);
+        return segment_type(this->_data.begin() + beg, this->_data.begin() + end);
     }
 
     /// @brief Returns a const segment at the given index without bounds checking.
@@ -488,7 +489,7 @@ class flat_jagged_vector {
     [[nodiscard]] const_segment_type operator[](size_type i) const {
         const auto beg = this->_offsets[i];
         const auto end = this->_offsets[i + 1uz];
-        return const_segment_type(this->_data.data() + beg, end - beg);
+        return const_segment_type(this->_data.begin() + beg, this->_data.begin() + end);
     }
 
     /// @brief Returns a reference to an element within a segment without bounds checking.
@@ -696,14 +697,20 @@ class flat_jagged_vector {
 
     /// @brief Returns a raw pointer to the underlying flat data array.
     /// @return A raw pointer to the first element in the `_data` array.
-    /// @warning No bounds checking is performed. Structural modifications (like resizing) cannot be done via this pointer; use `data_storage()` instead.
-    [[nodiscard]] value_type* data_ptr() noexcept {
+    /// @warning Structural modifications (like resizing) cannot be done via this pointer; use `data_storage()` instead.
+    /// @warning Not available for boolean vectors.
+    [[nodiscard]] value_type* data_ptr() noexcept
+    requires(not std::same_as<value_type, bool>)
+    {
         return this->_data.data();
     }
 
     /// @brief Returns a const raw pointer to the underlying flat data array.
     /// @return A const raw pointer to the first element in the `_data` array.
-    [[nodiscard]] const value_type* data_ptr() const noexcept {
+    /// @warning Not available for boolean vectors.
+    [[nodiscard]] const value_type* data_ptr() const noexcept
+    requires(not std::same_as<value_type, bool>)
+    {
         return this->_data.data();
     }
 
@@ -752,28 +759,28 @@ class flat_jagged_vector {
     /// @return Iterator to the first segment
     /// @note Iterator invalidated by structural modifications
     [[nodiscard]] iterator begin() noexcept {
-        return iterator(this->_data.data(), this->_offsets.data());
+        return iterator(this->_data.begin(), this->_offsets.data());
     }
 
     /// @brief Returns a mutable iterator past the last segment (end sentinel).
     /// @return Iterator one position past the last segment
     /// @note Iterator invalidated by structural modifications
     [[nodiscard]] iterator end() noexcept {
-        return iterator(this->_data.data(), this->_offsets.data() + this->size());
+        return iterator(this->_data.begin(), this->_offsets.data() + this->size());
     }
 
     /// @brief Returns a const iterator to the first segment.
     /// @return Const iterator to the first segment
     /// @note Iterator invalidated by structural modifications
     [[nodiscard]] const_iterator begin() const noexcept {
-        return const_iterator(this->_data.data(), this->_offsets.data());
+        return const_iterator(this->_data.begin(), this->_offsets.data());
     }
 
     /// @brief Returns a const iterator past the last segment (end sentinel).
     /// @return Const iterator one position past the last segment
     /// @note Iterator invalidated by structural modifications
     [[nodiscard]] const_iterator end() const noexcept {
-        return const_iterator(this->_data.data(), this->_offsets.data() + this->size());
+        return const_iterator(this->_data.begin(), this->_offsets.data() + this->size());
     }
 
     /// @brief Returns a const iterator to the first segment (explicit const form).

tests/source/gl/test_flat_jagged_vector.cpp

@@ -1550,6 +1550,22 @@ TEST_CASE_FIXTURE(
     }
 }
 
+TEST_CASE("flat_jagged_vector should work properly for boolean value type") {
+    using sut_type = gl::flat_jagged_vector<bool>;
+
+    std::vector<std::vector<bool>> data{
+        {true, false},
+        {false, true, false}
+    };
+    sut_type sut{data};
+
+    CHECK_EQ(sut.size(), data.size());
+    CHECK(std::ranges::all_of(std::views::zip(sut, data), [](const auto& entries) {
+        const auto& [segment, inner_vec] = entries;
+        return std::ranges::equal(segment, inner_vec);
+    }));
+}
+
 TEST_SUITE_END(); // test_flat_jagged_vector
 
 } // namespace gl_testing

tests/source/gl/test_flat_matrix.cpp

@@ -1650,6 +1650,22 @@ TEST_CASE_FIXTURE(
     CHECK_EQ(transposed.data_size(), 0uz);
 }
 
+TEST_CASE("flat_matrix should work properly for boolean value type") {
+    using sut_type = gl::flat_matrix<bool>;
+
+    std::vector<std::vector<bool>> data{
+        { true, false},
+        {false,  true}
+    };
+    sut_type sut{data};
+
+    CHECK_EQ(sut.size(), data.size());
+    CHECK(std::ranges::all_of(std::views::zip(sut, data), [](const auto& entries) {
+        const auto& [row, inner_vec] = entries;
+        return std::ranges::equal(row, inner_vec);
+    }));
+}
+
 TEST_SUITE_END(); // test_flat_matrix
 
 } // namespace gl_testing