highfive/bits/H5Dataspace_misc.hpp

0001 /*
0002  *  Copyright (c), 2017, Adrien Devresse <adrien.devresse@epfl.ch>
0003  *
0004  *  Distributed under the Boost Software License, Version 1.0.
0005  *    (See accompanying file LICENSE_1_0.txt or copy at
0006  *          http://www.boost.org/LICENSE_1_0.txt)
0007  *
0008  */
0009 #pragma once
0010
0011 #include <array>
0012 #include <initializer_list>
0013 #include <vector>
0014 #include <numeric>
0015
0016 #include <H5Spublic.h>
0017
0018 #include "H5Utils.hpp"
0019 #include "H5Converter_misc.hpp"
0020 #include "h5s_wrapper.hpp"
0021
0022 namespace HighFive {
0023
0024 namespace detail {
0025 inline DataSpace make_data_space(hid_t hid) {
0026     return DataSpace::fromId(hid);
0027 }
0028 }  // namespace detail
0029
0030 inline DataSpace::DataSpace(const std::vector<size_t>& dims)
0031     : DataSpace(dims.begin(), dims.end()) {}
0032
0033 template <size_t N>
0034 inline DataSpace::DataSpace(const std::array<size_t, N>& dims)
0035     : DataSpace(dims.begin(), dims.end()) {}
0036
0037 inline DataSpace::DataSpace(const std::initializer_list<size_t>& items)
0038     : DataSpace(std::vector<size_t>(items)) {}
0039
0040 template <typename... Args>
0041 inline DataSpace::DataSpace(size_t dim1, Args... dims)
0042     : DataSpace(std::vector<size_t>{dim1, static_cast<size_t>(dims)...}) {}
0043
0044 template <class IT, typename>
0045 inline DataSpace::DataSpace(const IT begin, const IT end) {
0046     std::vector<hsize_t> real_dims(begin, end);
0047
0048     _hid = detail::h5s_create_simple(int(real_dims.size()), real_dims.data(), nullptr);
0049 }
0050
0051 inline DataSpace DataSpace::Scalar() {
0052     return DataSpace(DataSpace::dataspace_scalar);
0053 }
0054
0055 inline DataSpace DataSpace::Null() {
0056     return DataSpace(DataSpace::dataspace_null);
0057 }
0058
0059 inline DataSpace::DataSpace(const std::vector<size_t>& dims, const std::vector<size_t>& maxdims) {
0060     if (dims.size() != maxdims.size()) {
0061         throw DataSpaceException("dims and maxdims must be the same length.");
0062     }
0063
0064     std::vector<hsize_t> real_dims(dims.begin(), dims.end());
0065     std::vector<hsize_t> real_maxdims(maxdims.begin(), maxdims.end());
0066
0067     // Replace unlimited flag with actual HDF one
0068     std::replace(real_maxdims.begin(),
0069                  real_maxdims.end(),
0070                  static_cast<hsize_t>(DataSpace::UNLIMITED),
0071                  H5S_UNLIMITED);
0072
0073     _hid = detail::h5s_create_simple(int(dims.size()), real_dims.data(), real_maxdims.data());
0074 }
0075
0076 inline DataSpace::DataSpace(DataSpace::DataspaceType space_type) {
0077     H5S_class_t h5_dataspace_type;
0078     switch (space_type) {
0079     case DataSpace::dataspace_scalar:
0080         h5_dataspace_type = H5S_SCALAR;
0081         break;
0082     case DataSpace::dataspace_null:
0083         h5_dataspace_type = H5S_NULL;
0084         break;
0085     default:
0086         throw DataSpaceException(
0087             "Invalid dataspace type: should be "
0088             "dataspace_scalar or dataspace_null");
0089     }
0090
0091     _hid = detail::h5s_create(h5_dataspace_type);
0092 }
0093
0094 inline DataSpace DataSpace::clone() const {
0095     DataSpace res;
0096     res._hid = detail::h5s_copy(_hid);
0097     return res;
0098 }
0099
0100 inline size_t DataSpace::getNumberDimensions() const {
0101     return static_cast<size_t>(detail::h5s_get_simple_extent_ndims(_hid));
0102 }
0103
0104 inline std::vector<size_t> DataSpace::getDimensions() const {
0105     std::vector<hsize_t> dims(getNumberDimensions());
0106     if (!dims.empty()) {
0107         detail::h5s_get_simple_extent_dims(_hid, dims.data(), nullptr);
0108     }
0109     return details::to_vector_size_t(std::move(dims));
0110 }
0111
0112 inline size_t DataSpace::getElementCount() const {
0113     return static_cast<size_t>(detail::h5s_get_simple_extent_npoints(_hid));
0114 }
0115
0116 inline std::vector<size_t> DataSpace::getMaxDimensions() const {
0117     std::vector<hsize_t> maxdims(getNumberDimensions());
0118     detail::h5s_get_simple_extent_dims(_hid, nullptr, maxdims.data());
0119
0120     std::replace(maxdims.begin(),
0121                  maxdims.end(),
0122                  H5S_UNLIMITED,
0123                  static_cast<hsize_t>(DataSpace::UNLIMITED));
0124     return details::to_vector_size_t(maxdims);
0125 }
0126
0127 template <typename T>
0128 inline DataSpace DataSpace::From(const T& value) {
0129     auto dims = details::inspector<T>::getDimensions(value);
0130     return DataSpace(dims);
0131 }
0132
0133 template <std::size_t N, std::size_t Width>
0134 inline DataSpace DataSpace::FromCharArrayStrings(const char (&)[N][Width]) {
0135     return DataSpace(N);
0136 }
0137
0138 namespace details {
0139
0140 /// dimension checks @internal
0141 inline bool checkDimensions(const DataSpace& mem_space, size_t n_dim_requested) {
0142     return checkDimensions(mem_space.getDimensions(), n_dim_requested);
0143 }
0144
0145 }  // namespace details
0146 }  // namespace HighFive