Avoid dynamic allocation with H5Sselect_hyperslab

include/highfive/H5DataSpace.hpp

@@ -82,7 +82,7 @@ class DataSpace: public Object {
     /// \endcode
     /// \since 2.3
     template <size_t N>
-    explicit DataSpace(const std::array<size_t, N>& dims);
+    constexpr explicit DataSpace(const std::array<size_t, N>& dims);
 
     /// \brief Create a DataSpace of N-dimensions from an initializer list.
     /// \param dims Dimensions of the new DataSpace

include/highfive/bits/H5Dataspace_misc.hpp

@@ -31,15 +31,18 @@ inline DataSpace::DataSpace(const std::vector<size_t>& dims)
     : DataSpace(dims.begin(), dims.end()) {}
 
 template <size_t N>
-inline DataSpace::DataSpace(const std::array<size_t, N>& dims)
-    : DataSpace(dims.begin(), dims.end()) {}
+constexpr DataSpace::DataSpace(const std::array<size_t, N>& dims) {
+    std::array<hsize_t, N> real_dims;
+    std::copy(dims.begin(), dims.end(), real_dims.begin());
+    _hid = detail::h5s_create_simple(static_cast<int>(N), real_dims.data(), nullptr);
+}
 
 inline DataSpace::DataSpace(const std::initializer_list<size_t>& items)
     : DataSpace(std::vector<size_t>(items)) {}
 
 template <typename... Args>
 inline DataSpace::DataSpace(size_t dim1, Args... dims)
-    : DataSpace(std::vector<size_t>{dim1, static_cast<size_t>(dims)...}) {}
+    : DataSpace(std::array{dim1, static_cast<size_t>(dims)...}) {}
 
 template <class IT, typename>
 inline DataSpace::DataSpace(const IT begin, const IT end) {

include/highfive/bits/H5Slice_traits.hpp

@@ -10,6 +10,9 @@
 
 #include <cstdlib>
 #include <vector>
+#if __cplusplus >= 201703L
+#include <optional>
+#endif
 
 #include "H5_definitions.hpp"
 #include "H5Utils.hpp"
@@ -416,7 +419,6 @@ class ProductSet {
     friend class SliceTraits;
 };
 
-
 template <typename Derivate>
 class SliceTraits {
   public:
@@ -428,7 +430,8 @@ class SliceTraits {
     /// nicely into a multi-dimensional array, but only a subset of such an array.
     ///
     /// Therefore, the only memspaces supported for general hyperslabs are one-dimensional arrays.
-    Selection select(const HyperSlab& hyper_slab) const;
+    template <class HyperSlabInterface>
+    Selection select(const HyperSlabInterface& hyper_slab) const;
 
     ///
     /// \brief Select an \p hyper_slab in the current Slice/Dataset.

include/highfive/bits/H5Slice_traits_misc.hpp

@@ -229,18 +229,18 @@ inline Selection SliceTraits<Derivate>::select(const HyperSlab& hyper_slab,
 }
 
 template <typename Derivate>
-inline Selection SliceTraits<Derivate>::select(const HyperSlab& hyper_slab) const {
+template <class HyperSlabInterface>
+inline Selection SliceTraits<Derivate>::select(const HyperSlabInterface& hyper_slab) const {
     const auto& slice = static_cast<const Derivate&>(*this);
     auto filespace = slice.getSpace();
     filespace = hyper_slab.apply(filespace);
 
-    auto n_elements = detail::h5s_get_select_npoints(filespace.getId());
-    auto memspace = DataSpace(std::array<size_t, 1>{size_t(n_elements)});
+    const auto n_elements = detail::h5s_get_select_npoints(filespace.getId());
+    auto memspace = DataSpace{static_cast<size_t>(n_elements)};
 
     return detail::make_selection(memspace, filespace, details::get_dataset(slice));
 }
 
-
 template <typename Derivate>
 inline Selection SliceTraits<Derivate>::select(const std::vector<size_t>& offset,
                                                const std::vector<size_t>& count,

src/examples/select_partial_dataset_cpp17.cpp

@@ -0,0 +1,97 @@
+/*
+ *  Copyright (c), 2017, Adrien Devresse
+ *
+ *  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)
+ *
+ */
+#include <functional>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <highfive/highfive.hpp>
+
+namespace {
+template <size_t Rank>
+struct RegularHyperSlabNoMalloc {
+    constexpr size_t rank() const {
+        return Rank;
+    }
+
+    /// Dimensions when all gaps are removed.
+    constexpr std::array<size_t, Rank> packedDims() const {
+        auto dims = std::array<size_t, Rank>{};
+
+        for (size_t i = 0; i < Rank; ++i) {
+            dims[i] = count[i] * (block ? (*block)[i] : 1);
+        }
+
+        return dims;
+    }
+
+    HighFive::DataSpace apply(const HighFive::DataSpace& space_) const {
+        auto space = space_.clone();
+        const auto error_code = H5Sselect_hyperslab(space.getId(),
+                                                    H5S_SELECT_SET,
+                                                    offset.data(),
+                                                    stride ? stride->data() : nullptr,
+                                                    count.data(),
+                                                    block ? block->data() : nullptr);
+
+        if (error_code < 0) {
+            HighFive::HDF5ErrMapper::ToException<HighFive::DataSpaceException>(
+                "Unable to select hyperslab");
+        }
+        return space;
+    }
+
+    std::array<hsize_t, Rank> offset{};
+    std::array<hsize_t, Rank> count{};
+    std::optional<std::array<hsize_t, Rank>> stride{std::nullopt};
+    std::optional<std::array<hsize_t, Rank>> block{std::nullopt};
+};
+}  // namespace
+
+int main(void) {
+    using namespace HighFive;
+
+    // Create a new file using the default property lists.
+    //
+    // Note: In C++14, using braces in constructor implies "explicit" keyword. Compiler logs will
+    // warn about possible implicit type conversion that may involves transient memory allocations.
+    File file{"select_partial_example_cpp17.h5", File::ReadWrite | File::Create | File::Truncate};
+
+    // we have some example values in a 2D vector 2x5
+    // Specifying the inner dimensions as std::array ensures that the two-dimensional data is
+    // contiguous, so that the compiler will only invoke one single memory allocation. The
+    // compiler also ensures the column counts are identical.
+    //
+    // Note: C++17 required.
+    const std::vector values{std::array{1.0, 2.0, 4.0, 8.0, 16.0},
+                             {32.0, 64.0, 128.0, 256.0, 512.0}};
+
+    // let's create a dataset of this size
+    DataSet dataset = file.createDataSet<double>("dset", DataSpace::From(values));
+    // and write them
+    dataset.write(values);
+
+
+    // now we read back 2x2 values after an offset of 0x2
+    // Notice that std::array lives in the stack space memory. No memory allocation required.
+    std::array<std::array<double, 2>, 2> result;
+
+    // Specify the selection without any memory allocations.
+    dataset.select(RegularHyperSlabNoMalloc<2>{{0, 2}, {2, 2}}).read_raw(result.front().data());
+
+    // we print out 4 values
+    for (auto i: result) {
+        for (auto j: i) {
+            std::cout << ' ' << j;
+        }
+        std::cout << '\n';
+    }
+
+    return 0;  // successfully terminated
+}