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/Variant.hpp"
24 #include "openPMD/backend/Attribute.hpp"
25 #include "openPMD/Dataset.hpp"
26 
27 #include <memory>
28 #include <map>
29 #include <vector>
30 #include <string>
31 #include <utility>
32 
33 #ifdef _MSC_VER
34 # define EXPORT __declspec( dllexport )
35 #elif defined(__NVCC__)
36 # define EXPORT
37 #else
38 # define EXPORT __attribute__((visibility("default")))
39 #endif
40 
41 
42 namespace openPMD
43 {
44 class Attributable;
45 class Writable;
46 
47 Writable*
48 getWritable(Attributable*);
49 
52 #if defined(__GNUC__) && (__GNUC__ < 6) && !defined(__clang__)
53 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43407
54 enum class Operation : EXPORT unsigned int
55 #else
56 enum class EXPORT Operation
57 #endif
58 {
59  CREATE_FILE,
60  OPEN_FILE,
61  DELETE_FILE,
62 
63  CREATE_PATH,
64  OPEN_PATH,
65  DELETE_PATH,
66  LIST_PATHS,
67 
68  CREATE_DATASET,
69  EXTEND_DATASET,
70  OPEN_DATASET,
71  DELETE_DATASET,
72  WRITE_DATASET,
73  READ_DATASET,
74  LIST_DATASETS,
75 
76  DELETE_ATT,
77  WRITE_ATT,
78  READ_ATT,
79  LIST_ATTS
80 }; //Operation
81 
82 struct EXPORT AbstractParameter
83 {
84  virtual ~AbstractParameter() = default;
85  AbstractParameter() = default;
86  //AbstractParameter(AbstractParameter&&) = default;
87 
88  // avoid object slicing
89  AbstractParameter(const AbstractParameter&) = delete;
90  AbstractParameter& operator=(const AbstractParameter&) = delete;
91  virtual std::unique_ptr< AbstractParameter > clone() const = 0;
92 };
93 
102 template< Operation >
103 struct EXPORT Parameter : public AbstractParameter
104 {
105  Parameter() = delete;
106  Parameter(Parameter const &) = delete;
107  Parameter(Parameter &&) = delete;
108 };
109 
110 template<>
111 struct EXPORT Parameter< Operation::CREATE_FILE > : public AbstractParameter
112 {
113  Parameter() = default;
114  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
115 
116  std::unique_ptr< AbstractParameter >
117  clone() const override
118  {
119  return std::unique_ptr< AbstractParameter >(
121  }
122 
123  std::string name = "";
124 };
125 
126 template<>
127 struct EXPORT Parameter< Operation::OPEN_FILE > : public AbstractParameter
128 {
129  Parameter() = default;
130  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
131 
132  std::unique_ptr< AbstractParameter >
133  clone() const override
134  {
135  return std::unique_ptr< AbstractParameter >(
137  }
138 
139  std::string name = "";
140 };
141 
142 template<>
143 struct EXPORT Parameter< Operation::DELETE_FILE > : public AbstractParameter
144 {
145  Parameter() = default;
146  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
147 
148  std::unique_ptr< AbstractParameter >
149  clone() const override
150  {
151  return std::unique_ptr< AbstractParameter >(
153  }
154 
155  std::string name = "";
156 };
157 
158 template<>
159 struct EXPORT Parameter< Operation::CREATE_PATH > : public AbstractParameter
160 {
161  Parameter() = default;
162  Parameter(Parameter const & p) : AbstractParameter(), path(p.path) {}
163 
164  std::unique_ptr< AbstractParameter >
165  clone() const override
166  {
167  return std::unique_ptr< AbstractParameter >(
169  }
170 
171  std::string path = "";
172 };
173 
174 template<>
175 struct EXPORT Parameter< Operation::OPEN_PATH > : public AbstractParameter
176 {
177  Parameter() = default;
178  Parameter(Parameter const & p) : AbstractParameter(), path(p.path) {}
179 
180  std::unique_ptr< AbstractParameter >
181  clone() const override
182  {
183  return std::unique_ptr< AbstractParameter >(
185  }
186 
187  std::string path = "";
188 };
189 
190 template<>
191 struct EXPORT Parameter< Operation::DELETE_PATH > : public AbstractParameter
192 {
193  Parameter() = default;
194  Parameter(Parameter const & p) : AbstractParameter(), path(p.path) {}
195 
196  std::unique_ptr< AbstractParameter >
197  clone() const override
198  {
199  return std::unique_ptr< AbstractParameter >(
201  }
202 
203  std::string path = "";
204 };
205 
206 template<>
207 struct EXPORT Parameter< Operation::LIST_PATHS > : public AbstractParameter
208 {
209  Parameter() = default;
210  Parameter(Parameter const & p) : AbstractParameter(), paths(p.paths) {}
211 
212  std::unique_ptr< AbstractParameter >
213  clone() const override
214  {
215  return std::unique_ptr< AbstractParameter >(
217  }
218 
219  std::shared_ptr< std::vector< std::string > > paths
220  = std::make_shared< std::vector< std::string > >();
221 };
222 
223 template<>
224 struct EXPORT Parameter< Operation::CREATE_DATASET > : public AbstractParameter
225 {
226  Parameter() = default;
227  Parameter(Parameter const & p) : AbstractParameter(),
228  name(p.name), extent(p.extent), dtype(p.dtype),
229  chunkSize(p.chunkSize), compression(p.compression),
230  transform(p.transform) {}
231 
232  std::unique_ptr< AbstractParameter >
233  clone() const override
234  {
235  return std::unique_ptr< AbstractParameter >(
237  }
238 
239  std::string name = "";
240  Extent extent = {};
241  Datatype dtype = Datatype::UNDEFINED;
242  Extent chunkSize = {};
243  std::string compression = "";
244  std::string transform = "";
245 };
246 
247 template<>
248 struct EXPORT Parameter< Operation::EXTEND_DATASET > : public AbstractParameter
249 {
250  Parameter() = default;
251  Parameter(Parameter const & p) : AbstractParameter(),
252  name(p.name), extent(p.extent) {}
253 
254  std::unique_ptr< AbstractParameter >
255  clone() const override
256  {
257  return std::unique_ptr< AbstractParameter >(
259  }
260 
261  std::string name = "";
262  Extent extent = {};
263 };
264 
265 template<>
266 struct EXPORT Parameter< Operation::OPEN_DATASET > : public AbstractParameter
267 {
268  Parameter() = default;
269  Parameter(Parameter const & p) : AbstractParameter(),
270  name(p.name), dtype(p.dtype), extent(p.extent) {}
271 
272  std::unique_ptr< AbstractParameter >
273  clone() const override
274  {
275  return std::unique_ptr< AbstractParameter >(
277  }
278 
279  std::string name = "";
280  std::shared_ptr< Datatype > dtype
281  = std::make_shared< Datatype >();
282  std::shared_ptr< Extent > extent
283  = std::make_shared< Extent >();
284 };
285 
286 template<>
287 struct EXPORT Parameter< Operation::DELETE_DATASET > : public AbstractParameter
288 {
289  Parameter() = default;
290  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
291 
292  std::unique_ptr< AbstractParameter >
293  clone() const override
294  {
295  return std::unique_ptr< AbstractParameter >(
297  }
298 
299  std::string name = "";
300 };
301 
302 template<>
303 struct EXPORT Parameter< Operation::WRITE_DATASET > : public AbstractParameter
304 {
305  Parameter() = default;
307  extent(p.extent), offset(p.offset), dtype(p.dtype),
308  data(p.data) {}
309 
310  Parameter& operator=(const Parameter& p) {
311  this->extent = p.extent;
312  this->offset = p.offset;
313  this->dtype = p.dtype;
314  this->data = p.data;
315  return *this;
316  }
317 
318  std::unique_ptr< AbstractParameter >
319  clone() const override
320  {
321  return std::unique_ptr< AbstractParameter >(
323  }
324 
325  Extent extent = {};
326  Offset offset = {};
327  Datatype dtype = Datatype::UNDEFINED;
328  std::shared_ptr< void const > data = nullptr;
329 };
330 
331 template<>
332 struct EXPORT Parameter< Operation::READ_DATASET > : public AbstractParameter
333 {
334  Parameter() = default;
336  extent(p.extent), offset(p.offset), dtype(p.dtype),
337  data(p.data) {}
338 
339  Parameter& operator=(const Parameter &p) {
340  this->extent = p.extent;
341  this->offset = p.offset;
342  this->dtype = p.dtype;
343  this->data = p.data;
344  return *this;
345  }
346 
347  std::unique_ptr< AbstractParameter >
348  clone() const override
349  {
350  return std::unique_ptr< AbstractParameter >(
352  }
353 
354  Extent extent = {};
355  Offset offset = {};
356  Datatype dtype = Datatype::UNDEFINED;
357  std::shared_ptr< void > data = nullptr;
358 };
359 
360 template<>
361 struct EXPORT Parameter< Operation::LIST_DATASETS > : public AbstractParameter
362 {
363  Parameter() = default;
364  Parameter(Parameter const & p) : AbstractParameter(),
365  datasets(p.datasets) {}
366 
367  std::unique_ptr< AbstractParameter >
368  clone() const override
369  {
370  return std::unique_ptr< AbstractParameter >(
372  }
373 
374  std::shared_ptr< std::vector< std::string > > datasets
375  = std::make_shared< std::vector< std::string > >();
376 };
377 
378 template<>
379 struct EXPORT Parameter< Operation::DELETE_ATT > : public AbstractParameter
380 {
381  Parameter() = default;
382  Parameter(Parameter const & p) : AbstractParameter(), name(p.name) {}
383 
384  std::unique_ptr< AbstractParameter >
385  clone() const override
386  {
387  return std::unique_ptr< AbstractParameter >(
389  }
390 
391  std::string name = "";
392 };
393 
394 template<>
395 struct EXPORT Parameter< Operation::WRITE_ATT > : public AbstractParameter
396 {
397  Parameter() = default;
398  Parameter(Parameter const & p) : AbstractParameter(),
399  name(p.name), dtype(p.dtype), resource(p.resource) {}
400 
401  std::unique_ptr< AbstractParameter >
402  clone() const override
403  {
404  return std::unique_ptr< AbstractParameter >(
406  }
407 
408  std::string name = "";
409  Datatype dtype = Datatype::UNDEFINED;
410  Attribute::resource resource;
411 };
412 
413 template<>
414 struct EXPORT Parameter< Operation::READ_ATT > : public AbstractParameter
415 {
416  Parameter() = default;
417  Parameter(Parameter const & p) : AbstractParameter(),
418  name(p.name), dtype(p.dtype), resource(p.resource) {}
419 
420  Parameter& operator=(const Parameter &p) {
421  this->name = p.name;
422  this->dtype = p.dtype;
423  this->resource = p.resource;
424  return *this;
425  }
426 
427  std::unique_ptr< AbstractParameter >
428  clone() const override
429  {
430  return std::unique_ptr< AbstractParameter >(
432  }
433 
434  std::string name = "";
435  std::shared_ptr< Datatype > dtype
436  = std::make_shared< Datatype >();
437  std::shared_ptr< Attribute::resource > resource
438  = std::make_shared< Attribute::resource >();
439 };
440 
441 template<>
442 struct EXPORT Parameter< Operation::LIST_ATTS > : public AbstractParameter
443 {
444  Parameter() = default;
445  Parameter(Parameter const & p) : AbstractParameter(),
446  attributes(p.attributes) {}
447 
448  std::unique_ptr< AbstractParameter >
449  clone() const override
450  {
451  return std::unique_ptr< AbstractParameter >(
453  }
454 
455  std::shared_ptr< std::vector< std::string > > attributes
456  = std::make_shared< std::vector< std::string > >();
457 };
458 
459 
468 class EXPORT IOTask
469 {
470 public:
477  template< Operation op >
478  explicit IOTask(Writable* w,
479  Parameter< op > const & p)
480  : writable{w},
481  operation{op},
482  parameter{p.clone()}
483  { }
484 
485  template< Operation op >
486  explicit IOTask(Attributable* a,
487  Parameter< op > const & p)
488  : writable{getWritable(a)},
489  operation{op},
490  parameter{p.clone()}
491  { }
492 
493  explicit IOTask(IOTask const & other) :
494  writable{other.writable},
495  operation{other.operation},
496  parameter{other.parameter}
497  {}
498 
499  IOTask& operator=(IOTask const & other)
500  {
501  writable = other.writable;
502  operation = other.operation;
503  parameter = other.parameter;
504  return *this;
505  }
506 
507  Writable* writable;
508  Operation operation;
509  std::shared_ptr< AbstractParameter > parameter;
510 }; // IOTask
511 } // namespace openPMD
512 
513 #undef EXPORT
Self-contained description of a single IO operation.
Definition: IOTask.hpp:468
Datatype
Concrete datatype of an object available at runtime.
Definition: Datatype.hpp:38
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:103
Definition: IOTask.hpp:82
Operation
Type of IO operation between logical and persistent data.
Definition: IOTask.hpp:56
IOTask(Writable *w, Parameter< op > const &p)
Constructor for self-contained description of single IO operation.
Definition: IOTask.hpp:478
Layer to manage storage of attributes associated with file objects.
Definition: Attributable.hpp:65