Check 'scalar <-> one-dimensional'.

include/highfive/bits/H5Attribute_misc.hpp

@@ -24,6 +24,7 @@
 #include "h5a_wrapper.hpp"
 #include "h5d_wrapper.hpp"
 #include "squeeze.hpp"
+#include "assert_compatible_spaces.hpp"
 
 namespace HighFive {
 
@@ -169,13 +170,7 @@ inline Attribute Attribute::squeezeMemSpace(const std::vector<size_t>& axes) con
 }
 
 inline Attribute Attribute::reshapeMemSpace(const std::vector<size_t>& new_dims) const {
-    auto n_elements_old = this->getMemSpace().getElementCount();
-    auto n_elements_new = compute_total_size(new_dims);
-    if (n_elements_old != n_elements_new) {
-        throw Exception("Invalid parameter `new_dims` number of elements differ: " +
-                        std::to_string(n_elements_old) + " (old) vs. " +
-                        std::to_string(n_elements_new) + " (new)");
-    }
+    detail::assert_compatible_spaces(this->getMemSpace(), new_dims);
 
     auto attr = *this;
     attr._mem_space = DataSpace(new_dims);

include/highfive/bits/H5Slice_traits_misc.hpp

@@ -22,6 +22,7 @@
 #include "H5Converter_misc.hpp"
 #include "squeeze.hpp"
 #include "compute_total_size.hpp"
+#include "assert_compatible_spaces.hpp"
 
 namespace HighFive {
 
@@ -316,14 +317,7 @@ template <typename Derivate>
 inline Selection SliceTraits<Derivate>::reshapeMemSpace(const std::vector<size_t>& new_dims) const {
     auto slice = static_cast<const Derivate&>(*this);
 
-    auto n_elements_old = slice.getMemSpace().getElementCount();
-    auto n_elements_new = compute_total_size(new_dims);
-    if (n_elements_old != n_elements_new) {
-        throw Exception("Invalid parameter `new_dims` number of elements differ: " +
-                        std::to_string(n_elements_old) + " (old) vs. " +
-                        std::to_string(n_elements_new) + " (new)");
-    }
-
+    detail::assert_compatible_spaces(slice.getMemSpace(), new_dims);
     return detail::make_selection(DataSpace(new_dims), slice.getSpace(), detail::getDataSet(slice));
 }
 

include/highfive/bits/assert_compatible_spaces.hpp

@@ -0,0 +1,29 @@
+/*
+ *  Copyright (c), 2024, BlueBrain Project, EPFL
+ *
+ *  Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ *
+ */
+#pragma once
+
+#include <vector>
+#include "../H5Exception.hpp"
+#include "../H5DataSpace.hpp"
+
+namespace HighFive {
+namespace detail {
+
+void assert_compatible_spaces(const DataSpace& old, const std::vector<size_t>& dims) {
+  auto n_elements_old = old.getElementCount();
+  auto n_elements_new = dims.size() == 0 ? 1 : compute_total_size(dims);
+
+  if (n_elements_old != n_elements_new) {
+      throw Exception("Invalid parameter `new_dims` number of elements differ: " +
+                      std::to_string(n_elements_old) + " (old) vs. " +
+                      std::to_string(n_elements_new) + " (new)");
+  }
+}
+}
+}

tests/unit/tests_high_five_base.cpp

@@ -1538,9 +1538,7 @@ TEST_CASE("squeeze") {
 }
 
 template <class CreateTraits>
-void check_modify_mem_space(File& file) {
-    const std::string name = "dset";
-
+void check_modify_memspace(File& file, const std::string& name) {
     auto expected_values = std::vector<double>{1.0, 2.0, 3.0};
     auto values = std::vector<std::vector<double>>{expected_values};
 
@@ -1564,14 +1562,63 @@ void check_modify_mem_space(File& file) {
     }
 }
 
-TEST_CASE("Modify Mem Space, attr") {
+TEST_CASE("Modify MemSpace, dset") {
     File file("h5_modify_memspace_dset.h5", File::Truncate);
-    check_modify_mem_space<testing::DataSetCreateTraits>(file);
+    check_modify_memspace<testing::DataSetCreateTraits>(file, "dset");
 }
 
-TEST_CASE("Modify Mem Space, dset") {
+TEST_CASE("Modify MemSpace, attr") {
     File file("h5_modify_memspace_attr.h5", File::Truncate);
-    check_modify_mem_space<testing::AttributeCreateTraits>(file);
+    check_modify_memspace<testing::AttributeCreateTraits>(file, "attr");
+}
+
+template <class CreateTraits>
+void check_modify_scalar_filespace(File& file, const std::string& name) {
+    auto expected_value = 3.0;
+
+    auto obj = CreateTraits::create(file, name, expected_value);
+    SECTION("reshape") {
+        auto actual_values = obj.reshapeMemSpace({1}).template read<std::vector<double>>();
+
+        REQUIRE(actual_values.size() == 1);
+        REQUIRE(actual_values[0] == expected_value);
+    }
+}
+
+TEST_CASE("Modify Scalar FileSpace, dset") {
+    File file("h5_modify_scalar_filespace_dset.h5", File::Truncate);
+    check_modify_scalar_filespace<testing::DataSetCreateTraits>(file, "dset");
+}
+
+TEST_CASE("Modify Scalar FileSpace, attr") {
+    File file("h5_modify_scalar_filespace_attr.h5", File::Truncate);
+    check_modify_scalar_filespace<testing::AttributeCreateTraits>(file, "attr");
+}
+
+template <class CreateTraits>
+void check_modify_scalar_memspace(File& file, const std::string& name) {
+    auto expected_value = std::vector<double>{3.0};
+
+    auto obj = CreateTraits::create(file, name, expected_value);
+    SECTION("squeeze") {
+        auto actual_value = obj.squeezeMemSpace({0}).template read<double>();
+        REQUIRE(actual_value == expected_value[0]);
+    }
+
+    SECTION("reshape") {
+        auto actual_value = obj.reshapeMemSpace({}).template read<double>();
+        REQUIRE(actual_value == expected_value[0]);
+    }
+}
+
+TEST_CASE("Modify Scalar MemSpace, dset") {
+    File file("h5_modify_scalar_memspace_dset.h5", File::Truncate);
+    check_modify_scalar_memspace<testing::DataSetCreateTraits>(file, "dset");
+}
+
+TEST_CASE("Modify Scalar MemSpace, attr") {
+    File file("h5_modify_scalar_memspace_attr.h5", File::Truncate);
+    check_modify_scalar_memspace<testing::AttributeCreateTraits>(file, "attr");
 }