cleanup

Author: 1uc

include/highfive/mdspan.hpp

@@ -27,20 +27,22 @@ struct mdspan_inspector {
 
     // mdspan is trivially copyable if the value type is trivially copyable
     // and the layout is contiguous (which is the default)
-    static constexpr bool is_trivially_copyable = 
+    static constexpr bool is_trivially_copyable =
         std::is_trivially_copyable<value_type>::value &&
         inspector<value_type>::is_trivially_nestable &&
         std::is_same_v<typename MdspanType::layout_type, std::layout_right>;
     static constexpr bool is_trivially_nestable = false;
 
-private:
+  private:
+    using index_type = typename extents_type::index_type;
+
     // Helper to access the first element (at index 0 in all dimensions)
     static auto get_first_element(const type& val) {
-        std::array<typename extents_type::index_type, ndim> indices{};
+        std::array<index_type, ndim> indices{};
         return val[indices];
     }
 
-public:
+  public:
     static size_t getRank(const type& val) {
         // Check if mdspan is empty (has zero size)
         if (val.size() == 0) {
@@ -113,8 +115,8 @@ struct mdspan_inspector {
         auto subsize = compute_total_size(subdims);
 
         // Create index array for iteration
-        std::array<typename extents_type::index_type, ndim> indices{};
-        
+        std::array<index_type, ndim> indices{};
+
         // Helper function to iterate through all elements
         auto iterate = [&](auto& self, size_t dim) -> void {
             if (dim == ndim) {
@@ -123,7 +125,8 @@ struct mdspan_inspector {
                 m += subsize;
             } else {
                 // Recursive case: iterate over current dimension
-                for (indices[dim] = 0; indices[dim] < static_cast<typename extents_type::index_type>(val.extent(dim)); ++indices[dim]) {
+                const auto n = static_cast<index_type>(val.extent(dim));
+                for (indices[dim] = 0; indices[dim] < n; ++indices[dim]) {
                     self(self, dim + 1);
                 }
             }
@@ -146,8 +149,8 @@ struct mdspan_inspector {
         auto subsize = compute_total_size(subdims);
 
         // Create index array for iteration
-        std::array<typename extents_type::index_type, ndim> indices{};
-        
+        std::array<index_type, ndim> indices{};
+
         // Helper function to iterate through all elements
         auto iterate = [&](auto& self, size_t dim) -> void {
             if (dim == ndim) {
@@ -156,15 +159,15 @@ struct mdspan_inspector {
                 vec_align += subsize;
             } else {
                 // Recursive case: iterate over current dimension
-                for (indices[dim] = 0; indices[dim] < static_cast<typename extents_type::index_type>(dims[dim]); ++indices[dim]) {
+                const auto n = static_cast<index_type>(dims[dim]);
+                for (indices[dim] = 0; indices[dim] < n; ++indices[dim]) {
                     self(self, dim + 1);
                 }
             }
         };
 
         iterate(iterate, 0);
     }
-
 };
 
 // Specialization for std::mdspan
@@ -183,4 +186,3 @@ struct inspector<std::mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>
 
 }  // namespace details
 }  // namespace HighFive
-

src/examples/read_write_std_mdspan.cpp

@@ -35,7 +35,7 @@ int main(void) {
         constexpr size_t rows = 3;
         constexpr size_t cols = 4;
         std::vector<double> values(rows * cols);
-        
+
         // Fill the data
         for (size_t i = 0; i < rows; ++i) {
             for (size_t j = 0; j < cols; ++j) {
@@ -60,15 +60,13 @@ int main(void) {
         // that memory:
         auto dims = dataset.getDimensions();
         auto values = std::vector<double>(dataset.getElementCount());
-        
+
         // Create an mdspan view over the preallocated memory using CTAD
-        auto view = std::mdspan(values.data(), 
-                                std::extents{dims[0], dims[1]});
+        auto view = std::mdspan(values.data(), std::extents{dims[0], dims[1]});
 
         // ... now we can read into the preallocated memory:
         dataset.read(view);
     }
 
     return 0;
 }
-

tests/unit/data_generator.hpp

@@ -718,30 +718,31 @@ struct MdspanContainerTraits {
         ContainerTraits<value_type>::sanitize_dims(dims, axis + rank);
     }
 
-private:
-    static std::array<typename extents_type::index_type, rank> extract_local_indices(const std::vector<size_t>& indices) {
+  private:
+    static std::array<typename extents_type::index_type, rank> extract_local_indices(
+        const std::vector<size_t>& indices) {
         std::array<typename extents_type::index_type, rank> local_indices;
         for (size_t i = 0; i < rank; ++i) {
             local_indices[i] = static_cast<typename extents_type::index_type>(indices[i]);
         }
         return local_indices;
     }
 
-    template<size_t... Is>
-    static extents_type create_extents_impl(const std::vector<size_t>& dims, std::index_sequence<Is...>) {
-        return extents_type{dims[Is]...};
-    }
-
     static extents_type create_extents(const std::vector<size_t>& dims) {
-        return create_extents_impl(dims, std::make_index_sequence<rank>{});
+        auto impl = [&dims]<size_t... Is>(std::index_sequence<Is...>) {
+            return extents_type{dims[Is]...};
+        };
+        return impl(std::make_index_sequence<rank>{});
     }
 };
 
 template <class ElementType, class Extents, class LayoutPolicy, class AccessorPolicy>
 struct ContainerTraits<std::mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>>
-    : public MdspanContainerTraits<std::mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>> {
+    : public MdspanContainerTraits<
+          std::mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>> {
   private:
-    using super = MdspanContainerTraits<std::mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>>;
+    using super =
+        MdspanContainerTraits<std::mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>>;
 
   public:
     using container_type = typename super::container_type;