HighFive 2.7.1
HighFive - Header-only C++ HDF5 interface
Loading...
Searching...
No Matches
H5Slice_traits.hpp
Go to the documentation of this file.
1/*
2 * Copyright (c), 2017, Adrien Devresse <adrien.devresse@epfl.ch>
3 *
4 * Distributed under the Boost Software License, Version 1.0.
5 * (See accompanying file LICENSE_1_0.txt or copy at
6 * http://www.boost.org/LICENSE_1_0.txt)
7 *
8 */
9#pragma once
10
11#include <cstdlib>
12#include <vector>
13
14#include "H5_definitions.hpp"
15#include "H5Utils.hpp"
16
17#include "../H5PropertyList.hpp"
18
19namespace HighFive {
20
22 public:
28 explicit ElementSet(std::initializer_list<std::size_t> list);
33 explicit ElementSet(std::initializer_list<std::vector<std::size_t>> list);
39 explicit ElementSet(const std::vector<std::size_t>& element_ids);
44 explicit ElementSet(const std::vector<std::vector<std::size_t>>& element_ids);
45
46 private:
47 std::vector<std::size_t> _ids;
48
49 template <typename Derivate>
50 friend class SliceTraits;
51};
52
53namespace detail {
54
55template <class To, class From>
56inline std::vector<To> convertSizeVector(const std::vector<From>& from) {
57 std::vector<To> to(from.size());
58 std::copy(from.cbegin(), from.cend(), to.begin());
59
60 return to;
61}
62} // namespace detail
63
64inline std::vector<hsize_t> toHDF5SizeVector(const std::vector<size_t>& from) {
65 return detail::convertSizeVector<hsize_t>(from);
66}
67
68inline std::vector<size_t> toSTLSizeVector(const std::vector<hsize_t>& from) {
69 return detail::convertSizeVector<size_t>(from);
70}
71
73 RegularHyperSlab() = default;
74
75 RegularHyperSlab(std::vector<size_t> offset_,
76 std::vector<size_t> count_ = {},
77 std::vector<size_t> stride_ = {},
78 std::vector<size_t> block_ = {})
79 : offset(toHDF5SizeVector(offset_))
80 , count(toHDF5SizeVector(count_))
81 , stride(toHDF5SizeVector(stride_))
82 , block(toHDF5SizeVector(block_)) {}
83
84 static RegularHyperSlab fromHDF5Sizes(std::vector<hsize_t> offset_,
85 std::vector<hsize_t> count_ = {},
86 std::vector<hsize_t> stride_ = {},
87 std::vector<hsize_t> block_ = {}) {
89 slab.offset = offset_;
90 slab.count = count_;
91 slab.stride = stride_;
92 slab.block = block_;
93
94 return slab;
95 }
96
97 size_t rank() const {
98 return std::max(std::max(offset.size(), count.size()),
99 std::max(stride.size(), block.size()));
100 }
101
103 std::vector<size_t> packedDims() const {
104 auto n_dims = rank();
105 auto dims = std::vector<size_t>(n_dims, 0);
106
107 for (size_t i = 0; i < n_dims; ++i) {
108 dims[i] = count[i] * (block.empty() ? 1 : block[i]);
109 }
110
111 return dims;
112 }
113
114 std::vector<hsize_t> offset;
115 std::vector<hsize_t> count;
116 std::vector<hsize_t> stride;
117 std::vector<hsize_t> block;
118};
119
121 public:
123 selects.emplace_back(RegularHyperSlab{}, Op::None);
124 };
125
126 explicit HyperSlab(const RegularHyperSlab& sel) {
127 selects.emplace_back(sel, Op::Set);
128 }
129
131 auto ret = *this;
132 ret |= sel;
133 return ret;
134 }
135
137 selects.emplace_back(sel, Op::Or);
138 return *this;
139 }
140
142 auto ret = *this;
143 ret &= sel;
144 return ret;
145 }
146
148 selects.emplace_back(sel, Op::And);
149 return *this;
150 }
151
153 auto ret = *this;
154 ret ^= sel;
155 return ret;
156 }
157
159 selects.emplace_back(sel, Op::Xor);
160 return *this;
161 }
162
164 selects.emplace_back(sel, Op::NotA);
165 return *this;
166 }
167
169 selects.emplace_back(sel, Op::NotB);
170 return *this;
171 }
172
173 DataSpace apply(const DataSpace& space_) const {
174 auto space = space_.clone();
175 for (const auto& sel: selects) {
176 if (sel.op == Op::None) {
177 H5Sselect_none(space.getId());
178 } else {
179 auto error_code =
180 H5Sselect_hyperslab(space.getId(),
181 convert(sel.op),
182 sel.offset.empty() ? nullptr : sel.offset.data(),
183 sel.stride.empty() ? nullptr : sel.stride.data(),
184 sel.count.empty() ? nullptr : sel.count.data(),
185 sel.block.empty() ? nullptr : sel.block.data());
186
187 if (error_code < 0) {
188 HDF5ErrMapper::ToException<DataSpaceException>("Unable to select hyperslab");
189 }
190 }
191 }
192 return space;
193 }
194
195 private:
196 enum class Op {
197 Noop,
198 Set,
199 Or,
200 And,
201 Xor,
202 NotB,
203 NotA,
204 Append,
205 Prepend,
206 Invalid,
207 None,
208 };
209
210 H5S_seloper_t convert(Op op) const {
211 switch (op) {
212 case Op::Noop:
213 return H5S_SELECT_NOOP;
214 case Op::Set:
215 return H5S_SELECT_SET;
216 case Op::Or:
217 return H5S_SELECT_OR;
218 case Op::And:
219 return H5S_SELECT_AND;
220 case Op::Xor:
221 return H5S_SELECT_XOR;
222 case Op::NotB:
223 return H5S_SELECT_NOTB;
224 case Op::NotA:
225 return H5S_SELECT_NOTA;
226 case Op::Append:
227 return H5S_SELECT_APPEND;
228 case Op::Prepend:
229 return H5S_SELECT_PREPEND;
230 case Op::Invalid:
231 return H5S_SELECT_INVALID;
232 default:
233 throw DataSpaceException("Invalid HyperSlab operation.");
234 }
235 }
236
237 struct Select_: public RegularHyperSlab {
238 Select_(const RegularHyperSlab& sel, Op op_)
239 : RegularHyperSlab(sel)
240 , op(op_) {}
241
242 Op op;
243 };
244
245 std::vector<Select_> selects;
246};
247
248template <typename Derivate>
250 public:
259 Selection select(const HyperSlab& hyperslab) const;
260
268 Selection select(const std::vector<size_t>& offset,
269 const std::vector<size_t>& count,
270 const std::vector<size_t>& stride = {},
271 const std::vector<size_t>& block = {}) const;
272
278 Selection select(const std::vector<size_t>& columns) const;
279
283 Selection select(const ElementSet& elements) const;
284
285 template <typename T>
286 T read(const DataTransferProps& xfer_props = DataTransferProps()) const;
287
297 template <typename T>
298 void read(T& array, const DataTransferProps& xfer_props = DataTransferProps()) const;
299
309 template <typename T>
310 void read(T* array,
311 const DataType& dtype = DataType(),
312 const DataTransferProps& xfer_props = DataTransferProps()) const;
313
321 template <typename T>
322 void write(const T& buffer, const DataTransferProps& xfer_props = DataTransferProps());
323
334 template <typename T>
335 void write_raw(const T* buffer,
336 const DataType& dtype = DataType(),
337 const DataTransferProps& xfer_props = DataTransferProps());
338
339 protected:
340 inline Selection select_impl(const HyperSlab& hyperslab, const DataSpace& memspace) const;
341};
342
343} // namespace HighFive
Class representing the space (dimensions) of a dataset.
Definition H5DataSpace.hpp:25
DataSpace clone() const
Definition H5Dataspace_misc.hpp:85
HDF5 Data Type.
Definition H5DataType.hpp:54
Definition H5Slice_traits.hpp:21
Definition H5Slice_traits.hpp:120
HyperSlab & notA(const RegularHyperSlab &sel)
Definition H5Slice_traits.hpp:163
HyperSlab & notB(const RegularHyperSlab &sel)
Definition H5Slice_traits.hpp:168
HyperSlab operator&(const RegularHyperSlab &sel) const
Definition H5Slice_traits.hpp:141
HyperSlab operator^(const RegularHyperSlab &sel) const
Definition H5Slice_traits.hpp:152
HyperSlab operator|(const RegularHyperSlab &sel) const
Definition H5Slice_traits.hpp:130
HyperSlab & operator&=(const RegularHyperSlab &sel)
Definition H5Slice_traits.hpp:147
HyperSlab()
Definition H5Slice_traits.hpp:122
HyperSlab & operator^=(const RegularHyperSlab &sel)
Definition H5Slice_traits.hpp:158
HyperSlab(const RegularHyperSlab &sel)
Definition H5Slice_traits.hpp:126
HyperSlab & operator|=(const RegularHyperSlab &sel)
Definition H5Slice_traits.hpp:136
DataSpace apply(const DataSpace &space_) const
Definition H5Slice_traits.hpp:173
HDF5 property Lists.
Definition H5PropertyList.hpp:79
Selection: represent a view on a slice/part of a dataset.
Definition H5Selection.hpp:27
Definition H5Slice_traits.hpp:249
T read(const DataTransferProps &xfer_props=DataTransferProps()) const
Definition H5Slice_traits_misc.hpp:162
void write(const T &buffer, const DataTransferProps &xfer_props=DataTransferProps())
Definition H5Slice_traits_misc.hpp:241
void write_raw(const T *buffer, const DataType &dtype=DataType(), const DataTransferProps &xfer_props=DataTransferProps())
Definition H5Slice_traits_misc.hpp:268
Selection select(const HyperSlab &hyperslab) const
Select an hyperslab in the current Slice/Dataset.
Definition H5Slice_traits_misc.hpp:82
Selection select_impl(const HyperSlab &hyperslab, const DataSpace &memspace) const
Definition H5Slice_traits_misc.hpp:67
Definition H5_definitions.hpp:15
PropertyList< PropertyType::DATASET_XFER > DataTransferProps
Definition H5PropertyList.hpp:110
std::vector< size_t > toSTLSizeVector(const std::vector< hsize_t > &from)
Definition H5Slice_traits.hpp:68
std::vector< hsize_t > toHDF5SizeVector(const std::vector< size_t > &from)
Definition H5Slice_traits.hpp:64
static void ToException(const std::string &prefix_msg)
Definition H5Exception_misc.hpp:42
Definition H5Slice_traits.hpp:72
size_t rank() const
Definition H5Slice_traits.hpp:97
std::vector< hsize_t > offset
Definition H5Slice_traits.hpp:114
std::vector< hsize_t > block
Definition H5Slice_traits.hpp:117
std::vector< size_t > packedDims() const
Dimensions when all gaps are removed.
Definition H5Slice_traits.hpp:103
RegularHyperSlab(std::vector< size_t > offset_, std::vector< size_t > count_={}, std::vector< size_t > stride_={}, std::vector< size_t > block_={})
Definition H5Slice_traits.hpp:75
std::vector< hsize_t > count
Definition H5Slice_traits.hpp:115
static RegularHyperSlab fromHDF5Sizes(std::vector< hsize_t > offset_, std::vector< hsize_t > count_={}, std::vector< hsize_t > stride_={}, std::vector< hsize_t > block_={})
Definition H5Slice_traits.hpp:84
std::vector< hsize_t > stride
Definition H5Slice_traits.hpp:116