openPMD-api
IOTask.hpp
1 /* Copyright 2017-2020 Fabian Koller
2  *
3  * This file is part of openPMD-api.
4  *
5  * openPMD-api is free software: you can redistribute it and/or modify
6  * it under the terms of of either the GNU General Public License or
7  * the GNU Lesser General Public License as published by
8  * the Free Software Foundation, either version 3 of the License, or
9  * (at your option) any later version.
10  *
11  * openPMD-api is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License and the GNU Lesser General Public License
15  * for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * and the GNU Lesser General Public License along with openPMD-api.
19  * If not, see <http://www.gnu.org/licenses/>.
20  */
21 #pragma once
22 
23 #include "openPMD/auxiliary/Export.hpp"
24 #include "openPMD/auxiliary/Variant.hpp"
25 #include "openPMD/backend/Attribute.hpp"
26 #include "openPMD/Dataset.hpp"
27 
28 #include <memory>
29 #include <map>
30 #include <vector>
31 #include <string>
32 #include <utility>
33 
34 
35 namespace openPMD
36 {
37 class Attributable;
38 class Writable;
39 
40 Writable*
41 getWritable(Attributable*);
42 
46 {
47  CREATE_FILE,
48  OPEN_FILE,
49  CLOSE_FILE,
50  DELETE_FILE,
51 
52  CREATE_PATH,
53  OPEN_PATH,
54  DELETE_PATH,
55  LIST_PATHS,
56 
57  CREATE_DATASET,
58  EXTEND_DATASET,
59  OPEN_DATASET,
60  DELETE_DATASET,
61  WRITE_DATASET,
62  READ_DATASET,
63  LIST_DATASETS,
64 
65  DELETE_ATT,
66  WRITE_ATT,
67  READ_ATT,
68  LIST_ATTS
69 }; //Operation
70 
71 struct OPENPMDAPI_EXPORT AbstractParameter
72 {
73  virtual ~AbstractParameter() = default;
74  AbstractParameter() = default;
75  //AbstractParameter(AbstractParameter&&) = default;
76 
77  // avoid object slicing
78  AbstractParameter(const AbstractParameter&) = delete;
79  AbstractParameter& operator=(const AbstractParameter&) = delete;
80  virtual std::unique_ptr< AbstractParameter > clone() const = 0;
81 };
82 
91 template< Operation >
92 struct OPENPMDAPI_EXPORT Parameter : public AbstractParameter
93 {
94  Parameter() = delete;
95  Parameter(Parameter const &) = delete;
96  Parameter(Parameter &&) = delete;
97 };
98 
99 template<>
100 struct OPENPMDAPI_EXPORT Parameter< Operation::CREATE_FILE > : public AbstractParameter
101 {
102  Parameter() = default;
103  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
104 
105  std::unique_ptr< AbstractParameter >
106  clone() const override
107  {
108  return std::unique_ptr< AbstractParameter >(
110  }
111 
112  std::string name = "";
113 };
114 
115 template<>
116 struct OPENPMDAPI_EXPORT Parameter< Operation::OPEN_FILE > : public AbstractParameter
117 {
118  Parameter() = default;
119  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
120 
121  std::unique_ptr< AbstractParameter >
122  clone() const override
123  {
124  return std::unique_ptr< AbstractParameter >(
126  }
127 
128  std::string name = "";
129 };
130 
131 template<>
132 struct OPENPMDAPI_EXPORT Parameter< Operation::CLOSE_FILE > : public AbstractParameter
133 {
134  Parameter() = default;
135  Parameter( Parameter const & ) : AbstractParameter() {}
136 
137  std::unique_ptr< AbstractParameter >
138  clone() const override
139  {
140  return std::unique_ptr< AbstractParameter >(
141  new Parameter< Operation::CLOSE_FILE >( *this ) );
142  }
143 };
144 
145 template<>
146 struct OPENPMDAPI_EXPORT Parameter< Operation::DELETE_FILE > : public AbstractParameter
147 {
148  Parameter() = default;
149  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
150 
151  std::unique_ptr< AbstractParameter >
152  clone() const override
153  {
154  return std::unique_ptr< AbstractParameter >(
156  }
157 
158  std::string name = "";
159 };
160 
161 template<>
162 struct OPENPMDAPI_EXPORT Parameter< Operation::CREATE_PATH > : public AbstractParameter
163 {
164  Parameter() = default;
165  Parameter(Parameter const & p) : AbstractParameter(), path(p.path) {}
166 
167  std::unique_ptr< AbstractParameter >
168  clone() const override
169  {
170  return std::unique_ptr< AbstractParameter >(
172  }
173 
174  std::string path = "";
175 };
176 
177 template<>
178 struct OPENPMDAPI_EXPORT Parameter< Operation::OPEN_PATH > : public AbstractParameter
179 {
180  Parameter() = default;
181  Parameter(Parameter const & p) : AbstractParameter(), path(p.path) {}
182 
183  std::unique_ptr< AbstractParameter >
184  clone() const override
185  {
186  return std::unique_ptr< AbstractParameter >(
188  }
189 
190  std::string path = "";
191 };
192 
193 template<>
194 struct OPENPMDAPI_EXPORT Parameter< Operation::DELETE_PATH > : public AbstractParameter
195 {
196  Parameter() = default;
197  Parameter(Parameter const & p) : AbstractParameter(), path(p.path) {}
198 
199  std::unique_ptr< AbstractParameter >
200  clone() const override
201  {
202  return std::unique_ptr< AbstractParameter >(
204  }
205 
206  std::string path = "";
207 };
208 
209 template<>
210 struct OPENPMDAPI_EXPORT Parameter< Operation::LIST_PATHS > : public AbstractParameter
211 {
212  Parameter() = default;
213  Parameter(Parameter const & p) : AbstractParameter(), paths(p.paths) {}
214 
215  std::unique_ptr< AbstractParameter >
216  clone() const override
217  {
218  return std::unique_ptr< AbstractParameter >(
220  }
221 
222  std::shared_ptr< std::vector< std::string > > paths
223  = std::make_shared< std::vector< std::string > >();
224 };
225 
226 template<>
227 struct OPENPMDAPI_EXPORT Parameter< Operation::CREATE_DATASET > : public AbstractParameter
228 {
229  Parameter() = default;
230  Parameter(Parameter const & p) : AbstractParameter(),
231  name(p.name), extent(p.extent), dtype(p.dtype),
232  chunkSize(p.chunkSize), compression(p.compression),
233  transform(p.transform) {}
234 
235  std::unique_ptr< AbstractParameter >
236  clone() const override
237  {
238  return std::unique_ptr< AbstractParameter >(
240  }
241 
242  std::string name = "";
243  Extent extent = {};
244  Datatype dtype = Datatype::UNDEFINED;
245  Extent chunkSize = {};
246  std::string compression = "";
247  std::string transform = "";
248 };
249 
250 template<>
251 struct OPENPMDAPI_EXPORT Parameter< Operation::EXTEND_DATASET > : public AbstractParameter
252 {
253  Parameter() = default;
254  Parameter(Parameter const & p) : AbstractParameter(),
255  name(p.name), extent(p.extent) {}
256 
257  std::unique_ptr< AbstractParameter >
258  clone() const override
259  {
260  return std::unique_ptr< AbstractParameter >(
262  }
263 
264  std::string name = "";
265  Extent extent = {};
266 };
267 
268 template<>
269 struct OPENPMDAPI_EXPORT Parameter< Operation::OPEN_DATASET > : public AbstractParameter
270 {
271  Parameter() = default;
272  Parameter(Parameter const & p) : AbstractParameter(),
273  name(p.name), dtype(p.dtype), extent(p.extent) {}
274 
275  std::unique_ptr< AbstractParameter >
276  clone() const override
277  {
278  return std::unique_ptr< AbstractParameter >(
280  }
281 
282  std::string name = "";
283  std::shared_ptr< Datatype > dtype
284  = std::make_shared< Datatype >();
285  std::shared_ptr< Extent > extent
286  = std::make_shared< Extent >();
287 };
288 
289 template<>
290 struct OPENPMDAPI_EXPORT Parameter< Operation::DELETE_DATASET > : public AbstractParameter
291 {
292  Parameter() = default;
293  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
294 
295  std::unique_ptr< AbstractParameter >
296  clone() const override
297  {
298  return std::unique_ptr< AbstractParameter >(
300  }
301 
302  std::string name = "";
303 };
304 
305 template<>
306 struct OPENPMDAPI_EXPORT Parameter< Operation::WRITE_DATASET > : public AbstractParameter
307 {
308  Parameter() = default;
310  extent(p.extent), offset(p.offset), dtype(p.dtype),
311  data(p.data) {}
312 
313  Parameter& operator=(const Parameter& p) {
314  this->extent = p.extent;
315  this->offset = p.offset;
316  this->dtype = p.dtype;
317  this->data = p.data;
318  return *this;
319  }
320 
321  std::unique_ptr< AbstractParameter >
322  clone() const override
323  {
324  return std::unique_ptr< AbstractParameter >(
326  }
327 
328  Extent extent = {};
329  Offset offset = {};
330  Datatype dtype = Datatype::UNDEFINED;
331  std::shared_ptr< void const > data = nullptr;
332 };
333 
334 template<>
335 struct OPENPMDAPI_EXPORT Parameter< Operation::READ_DATASET > : public AbstractParameter
336 {
337  Parameter() = default;
339  extent(p.extent), offset(p.offset), dtype(p.dtype),
340  data(p.data) {}
341 
342  Parameter& operator=(const Parameter &p) {
343  this->extent = p.extent;
344  this->offset = p.offset;
345  this->dtype = p.dtype;
346  this->data = p.data;
347  return *this;
348  }
349 
350  std::unique_ptr< AbstractParameter >
351  clone() const override
352  {
353  return std::unique_ptr< AbstractParameter >(
355  }
356 
357  Extent extent = {};
358  Offset offset = {};
359  Datatype dtype = Datatype::UNDEFINED;
360  std::shared_ptr< void > data = nullptr;
361 };
362 
363 template<>
364 struct OPENPMDAPI_EXPORT Parameter< Operation::LIST_DATASETS > : public AbstractParameter
365 {
366  Parameter() = default;
367  Parameter(Parameter const & p) : AbstractParameter(),
368  datasets(p.datasets) {}
369 
370  std::unique_ptr< AbstractParameter >
371  clone() const override
372  {
373  return std::unique_ptr< AbstractParameter >(
375  }
376 
377  std::shared_ptr< std::vector< std::string > > datasets
378  = std::make_shared< std::vector< std::string > >();
379 };
380 
381 template<>
382 struct OPENPMDAPI_EXPORT Parameter< Operation::DELETE_ATT > : public AbstractParameter
383 {
384  Parameter() = default;
385  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
386 
387  std::unique_ptr< AbstractParameter >
388  clone() const override
389  {
390  return std::unique_ptr< AbstractParameter >(
392  }
393 
394  std::string name = "";
395 };
396 
397 template<>
398 struct OPENPMDAPI_EXPORT Parameter< Operation::WRITE_ATT > : public AbstractParameter
399 {
400  Parameter() = default;
401  Parameter(Parameter const & p) : AbstractParameter(),
402  name(p.name), dtype(p.dtype), resource(p.resource) {}
403 
404  std::unique_ptr< AbstractParameter >
405  clone() const override
406  {
407  return std::unique_ptr< AbstractParameter >(
409  }
410 
411  std::string name = "";
412  Datatype dtype = Datatype::UNDEFINED;
413  Attribute::resource resource;
414 };
415 
416 template<>
417 struct OPENPMDAPI_EXPORT Parameter< Operation::READ_ATT > : public AbstractParameter
418 {
419  Parameter() = default;
420  Parameter(Parameter const & p) : AbstractParameter(),
421  name(p.name), dtype(p.dtype), resource(p.resource) {}
422 
423  Parameter& operator=(const Parameter &p) {
424  this->name = p.name;
425  this->dtype = p.dtype;
426  this->resource = p.resource;
427  return *this;
428  }
429 
430  std::unique_ptr< AbstractParameter >
431  clone() const override
432  {
433  return std::unique_ptr< AbstractParameter >(
435  }
436 
437  std::string name = "";
438  std::shared_ptr< Datatype > dtype
439  = std::make_shared< Datatype >();
440  std::shared_ptr< Attribute::resource > resource
441  = std::make_shared< Attribute::resource >();
442 };
443 
444 template<>
445 struct OPENPMDAPI_EXPORT Parameter< Operation::LIST_ATTS > : public AbstractParameter
446 {
447  Parameter() = default;
448  Parameter(Parameter const & p) : AbstractParameter(),
449  attributes(p.attributes) {}
450 
451  std::unique_ptr< AbstractParameter >
452  clone() const override
453  {
454  return std::unique_ptr< AbstractParameter >(
456  }
457 
458  std::shared_ptr< std::vector< std::string > > attributes
459  = std::make_shared< std::vector< std::string > >();
460 };
461 
462 
471 class OPENPMDAPI_EXPORT IOTask
472 {
473 public:
480  template< Operation op >
481  explicit IOTask(Writable* w,
482  Parameter< op > const & p)
483  : writable{w},
484  operation{op},
485  parameter{p.clone()}
486  { }
487 
488  template< Operation op >
489  explicit IOTask(Attributable* a,
490  Parameter< op > const & p)
491  : writable{getWritable(a)},
492  operation{op},
493  parameter{p.clone()}
494  { }
495 
496  explicit IOTask(IOTask const & other) :
497  writable{other.writable},
498  operation{other.operation},
499  parameter{other.parameter}
500  {}
501 
502  IOTask& operator=(IOTask const & other)
503  {
504  writable = other.writable;
505  operation = other.operation;
506  parameter = other.parameter;
507  return *this;
508  }
509 
510  Writable* writable;
511  Operation operation;
512  std::shared_ptr< AbstractParameter > parameter;
513 }; // IOTask
514 } // namespace openPMD
Self-contained description of a single IO operation.
Definition: IOTask.hpp:471
Datatype
Concrete datatype of an object available at runtime.
Definition: Datatype.hpp:42
Public definitions of openPMD-api.
Definition: Date.cpp:28
Layer to mirror structure of logical data and persistent data in file.
Definition: Writable.hpp:55
Typesafe description of all required arguments for a specified Operation.
Definition: IOTask.hpp:92
OPENPMDAPI_EXPORT_ENUM_CLASS(Operation)
Type of IO operation between logical and persistent data.
Definition: IOTask.hpp:45
Definition: IOTask.hpp:71
IOTask(Writable *w, Parameter< op > const &p)
Constructor for self-contained description of single IO operation.
Definition: IOTask.hpp:481
Layer to manage storage of attributes associated with file objects.
Definition: Attributable.hpp:65