QMCPACK
IOVarBase.h
Go to the documentation of this file.
1 //////////////////////////////////////////////////////////////////////////////////////
2 // This file is distributed under the University of Illinois/NCSA Open Source License.
3 // See LICENSE file in top directory for details.
4 //
5 // Copyright (c) 2016 Jeongnim Kim and QMCPACK developers.
6 //
7 // File developed by: Paul R. C. Kent, kentpr@ornl.gov, Oak Ridge National Laboratory
8 // Mark A. Berrill, berrillma@ornl.gov, Oak Ridge National Laboratory
9 //
10 // File created by: Paul R. C. Kent, kentpr@ornl.gov, Oak Ridge National Laboratory
11 //////////////////////////////////////////////////////////////////////////////////////
12 
13 
14 // http://pathintegrals.info //
15 /////////////////////////////////////////////////////////////
16 
17 #ifndef IO_VAR_BASE_H
18 #define IO_VAR_BASE_H
19 
20 #include <iostream>
21 
22 #include "Blitz.h"
23 
24 namespace IO
25 {
26 typedef enum
27 {
28  DOUBLE_TYPE,
29  INT_TYPE,
30  STRING_TYPE,
31  BOOL_TYPE,
32  COMPLEX_TYPE,
33  INVALID
34 } IODataType;
35 typedef enum
36 {
37  ASCII_TYPE
38 } IOFileType;
39 
40 ///////////////////////////////////////////////////////////////////
41 /// The following is a template trick for counting how many ///
42 /// dimension reductions we have made to a dataset by indexing ///
43 /// by integer arguments. ///
44 ///////////////////////////////////////////////////////////////////
45 template<typename T>
46 class SliceCheck
47 {
48 public:
49  static const int isSlice = 0;
50 };
51 
52 template<>
53 class SliceCheck<int>
54 {
55 public:
56  static const int isSlice = 1;
57 };
58 
59 class IOVarBase
60 {
61 private:
62  nilArraySection n0;
63 
64 protected:
65  std::string Name;
66 
67 public:
68  virtual int GetRank() = 0;
69  virtual IODataType GetType() = 0;
70  virtual IOFileType GetFileType() = 0;
71  virtual void Print(std::ofstream& out)
72  { /* do nothing */
73  }
74  // virtual std::string GetTypeString() = 0;
75  std::string GetName() const { return Name; }
76  virtual int GetExtent(int dim) = 0;
77 
78  /// Resizes the first dimension of the variable
79  virtual void Resize(int n) = 0;
80 
81  //////////////////////
82  /// Read functions ///
83  //////////////////////
84  template<typename T>
85  bool Read(T& val);
86  template<typename T, int LEN>
87  bool Read(TinyVector<T, LEN>& val);
88  template<typename T, int RANK>
89  bool Read(Array<T, RANK>& val);
90 
91  template<typename T,
92  int RANK,
93  typename T0,
94  typename T1,
95  typename T2,
96  typename T3,
97  typename T4,
98  typename T5,
99  typename T6,
100  typename T7,
101  typename T8,
102  typename T9,
103  typename T10>
104  bool Read(Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8, T9 s9, T10 s10);
105 
106  template<typename T,
107  int RANK,
108  typename T0,
109  typename T1,
110  typename T2,
111  typename T3,
112  typename T4,
113  typename T5,
114  typename T6,
115  typename T7,
116  typename T8,
117  typename T9>
118  bool Read(Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8, T9 s9)
119  {
120  return Read(val, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, n0);
121  }
122 
123  template<typename T,
124  int RANK,
125  typename T0,
126  typename T1,
127  typename T2,
128  typename T3,
129  typename T4,
130  typename T5,
131  typename T6,
132  typename T7,
133  typename T8>
134  bool Read(Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8)
135  {
136  return Read(val, s0, s1, s2, s3, s4, s5, s6, s7, s8, n0, n0);
137  }
138 
139  template<typename T,
140  int RANK,
141  typename T0,
142  typename T1,
143  typename T2,
144  typename T3,
145  typename T4,
146  typename T5,
147  typename T6,
148  typename T7>
149  bool Read(Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7)
150  {
151  return Read(val, s0, s1, s2, s3, s4, s5, s6, s7, n0, n0, n0);
152  }
153 
154  template<typename T,
155  int RANK,
156  typename T0,
157  typename T1,
158  typename T2,
159  typename T3,
160  typename T4,
161  typename T5,
162  typename T6>
163  bool Read(Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6)
164  {
165  return Read(val, s0, s1, s2, s3, s4, s5, s6, n0, n0, n0, n0);
166  }
167 
168  template<typename T, int RANK, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
169  bool Read(Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5)
170  {
171  return Read(val, s0, s1, s2, s3, s4, s5, n0, n0, n0, n0, n0);
172  }
173 
174  template<typename T, int RANK, typename T0, typename T1, typename T2, typename T3, typename T4>
175  bool Read(Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4)
176  {
177  return Read(val, s0, s1, s2, s3, s4, n0, n0, n0, n0, n0, n0);
178  }
179 
180  template<typename T, int RANK, typename T0, typename T1, typename T2, typename T3>
181  bool Read(Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3)
182  {
183  return Read(val, s0, s1, s2, s3, n0, n0, n0, n0, n0, n0, n0);
184  }
185 
186  template<typename T, int RANK, typename T0, typename T1, typename T2>
187  bool Read(Array<T, RANK>& val, T0 s0, T1 s1, T2 s2)
188  {
189  return Read(val, s0, s1, s2, n0, n0, n0, n0, n0, n0, n0, n0);
190  }
191 
192  template<typename T, int RANK, typename T0, typename T1>
193  bool Read(Array<T, RANK>& val, T0 s0, T1 s1)
194  {
195  return Read(val, s0, s1, n0, n0, n0, n0, n0, n0, n0, n0, n0);
196  }
197 
198  template<typename T, int RANK, typename T0>
199  bool Read(Array<T, RANK>& val, T0 s0)
200  {
201  return Read(val, s0, n0, n0, n0, n0, n0, n0, n0, n0, n0, n0);
202  }
203 
204 
205  ///////////////////////
206  /// Write functions ///
207  ///////////////////////
208  template<typename T,
209  int RANK,
210  typename T0,
211  typename T1,
212  typename T2,
213  typename T3,
214  typename T4,
215  typename T5,
216  typename T6,
217  typename T7,
218  typename T8,
219  typename T9,
220  typename T10>
221  bool Write(const Array<T, RANK>& val,
222  T0 s0,
223  T1 s1,
224  T2 s2,
225  T3 s3,
226  T4 s4,
227  T5 s5,
228  T6 s6,
229  T7 s7,
230  T8 s8,
231  T9 s9,
232  T10 s10);
233 
234  template<typename T,
235  int RANK,
236  typename T0,
237  typename T1,
238  typename T2,
239  typename T3,
240  typename T4,
241  typename T5,
242  typename T6,
243  typename T7,
244  typename T8,
245  typename T9>
246  bool Write(const Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8, T9 s9)
247  {
248  return Write(val, s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, n0);
249  }
250 
251  template<typename T,
252  int RANK,
253  typename T0,
254  typename T1,
255  typename T2,
256  typename T3,
257  typename T4,
258  typename T5,
259  typename T6,
260  typename T7,
261  typename T8>
262  bool Write(const Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8)
263  {
264  return Write(val, s0, s1, s2, s3, s4, s5, s6, s7, s8, n0, n0);
265  }
266 
267  template<typename T,
268  int RANK,
269  typename T0,
270  typename T1,
271  typename T2,
272  typename T3,
273  typename T4,
274  typename T5,
275  typename T6,
276  typename T7>
277  bool Write(const Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7)
278  {
279  return Write(val, s0, s1, s2, s3, s4, s5, s6, s7, n0, n0, n0);
280  }
281 
282  template<typename T,
283  int RANK,
284  typename T0,
285  typename T1,
286  typename T2,
287  typename T3,
288  typename T4,
289  typename T5,
290  typename T6>
291  bool Write(const Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6)
292  {
293  return Write(val, s0, s1, s2, s3, s4, s5, s6, n0, n0, n0, n0);
294  }
295 
296  template<typename T, int RANK, typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
297  bool Write(const Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5)
298  {
299  return Write(val, s0, s1, s2, s3, s4, s5, n0, n0, n0, n0, n0);
300  }
301 
302  template<typename T, int RANK, typename T0, typename T1, typename T2, typename T3, typename T4>
303  bool Write(const Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4)
304  {
305  return Write(val, s0, s1, s2, s3, s4, n0, n0, n0, n0, n0, n0);
306  }
307 
308  template<typename T, int RANK, typename T0, typename T1, typename T2, typename T3>
309  bool Write(const Array<T, RANK>& val, T0 s0, T1 s1, T2 s2, T3 s3)
310  {
311  return Write(val, s0, s1, s2, s3, n0, n0, n0, n0, n0, n0, n0);
312  }
313 
314  template<typename T, int RANK, typename T0, typename T1, typename T2>
315  bool Write(const Array<T, RANK>& val, T0 s0, T1 s1, T2 s2)
316  {
317  return Write(val, s0, s1, s2, n0, n0, n0, n0, n0, n0, n0, n0);
318  }
319 
320  template<typename T, int RANK, typename T0, typename T1>
321  bool Write(const Array<T, RANK>& val, T0 s0, T1 s1)
322  {
323  return Write(val, s0, s1, n0, n0, n0, n0, n0, n0, n0, n0, n0);
324  }
325 
326  template<typename T, int RANK, typename T0>
327  bool Write(const Array<T, RANK>& val, T0 s0)
328  {
329  return Write(val, s0, n0, n0, n0, n0, n0, n0, n0, n0, n0, n0);
330  }
331 
332  template<typename T>
333  bool Append(const T val);
334  template<class T>
335  bool Append(const Array<T, 1>& val);
336  template<class T>
337  bool Append(const Array<T, 2>& val);
338  template<class T>
339  bool Append(const Array<T, 3>& val);
340  template<class T>
341  bool Append(const Array<T, 4>& val);
342 
343  virtual ~IOVarBase()
344  { /* do nothing at this level */
345  }
346 };
347 
348 
349 ///////////////////////////////////////////////////////////////////
350 /// The following are template tricks for converting a C++ type ///
351 /// into an enumerated type variable. ///
352 ///////////////////////////////////////////////////////////////////
353 template<typename T>
354 class TypeConvert
355 {
356 public:
357  static const IODataType Type = INVALID;
358 };
359 
360 template<>
361 class TypeConvert<double>
362 {
363 public:
364  static const IODataType Type = DOUBLE_TYPE;
365 };
366 
367 template<>
368 class TypeConvert<int>
369 {
370 public:
371  static const IODataType Type = INT_TYPE;
372 };
373 
374 template<>
375 class TypeConvert<std::string>
376 {
377 public:
378  static const IODataType Type = STRING_TYPE;
379 };
380 
381 template<>
382 class TypeConvert<bool>
383 {
384 public:
385  static const IODataType Type = BOOL_TYPE;
386 };
387 
388 template<>
389 class TypeConvert<std::complex<double>>
390 {
391 public:
392  static const IODataType Type = COMPLEX_TYPE;
393 };
394 
395 
396 template<typename T>
397 inline std::string TypeString(T& val)
398 {
399  return "unknown";
400 }
401 template<>
402 std::string inline TypeString(double& val)
403 {
404  return "double";
405 }
406 template<>
407 std::string inline TypeString(int& val)
408 {
409  return "int";
410 }
411 template<>
412 std::string inline TypeString(std::string& val)
413 {
414  return "string";
415 }
416 template<>
417 std::string inline TypeString(bool& val)
418 {
419  return "bool";
420 }
421 template<>
422 std::string inline TypeString(std::complex<double>& val)
423 {
424  return "complex";
425 }
426 
427 } // namespace IO
428 
429 
430 #endif // ifndef IO_BASE_H
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8)
Definition: IOVarBase.h:262
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0)
Definition: IOVarBase.h:199
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1)
Definition: IOVarBase.h:321
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8, T9 s9, T10 s10)
Write functions ///.
Definition: IOVar.h:156
IO::TypeConvert
The following are template tricks for converting a C++ type /// into an enumerated type variable...
Definition: IOVarBase.h:354
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4)
Definition: IOVarBase.h:303
IO::IODataType
IODataType
Definition: IOVarBase.h:26
IO::IOVarBase::Name
std::string Name
Definition: IOVarBase.h:65
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6)
Definition: IOVarBase.h:163
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6)
Definition: IOVarBase.h:291
IO::TypeConvert::Type
static const IODataType Type
Definition: IOVarBase.h:357
IO::IOFileType
IOFileType
Definition: IOVarBase.h:35
IO::SliceCheck
The following is a template trick for counting how many /// dimension reductions we have made to a da...
Definition: IOVarBase.h:46
IO::IOVarBase::GetExtent
virtual int GetExtent(int dim)=0
IO
Definition: IO.h:24
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0)
Definition: IOVarBase.h:327
IO::SliceCheck::isSlice
static const int isSlice
Definition: IOVarBase.h:49
IO::IOVarBase::Print
virtual void Print(std::ofstream &out)
Definition: IOVarBase.h:71
IO::IOVarBase::GetFileType
virtual IOFileType GetFileType()=0
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4)
Definition: IOVarBase.h:175
IO::IOVarBase::n0
nilArraySection n0
Definition: IOVarBase.h:62
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8, T9 s9)
Definition: IOVarBase.h:246
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0, T1 s1)
Definition: IOVarBase.h:193
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3)
Definition: IOVarBase.h:309
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7)
Definition: IOVarBase.h:149
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2)
Definition: IOVarBase.h:315
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5)
Definition: IOVarBase.h:297
IO::IOVarBase::GetType
virtual IODataType GetType()=0
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0, T1 s1, T2 s2)
Definition: IOVarBase.h:187
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5)
Definition: IOVarBase.h:169
IO::IOVarBase::Append
bool Append(const T val)
Definition: IOVar.h:190
IO::IOVarBase::GetName
std::string GetName() const
Definition: IOVarBase.h:75
IO::IOVarBase::~IOVarBase
virtual ~IOVarBase()
Definition: IOVarBase.h:343
IO::TypeString
std::string TypeString(T &val)
Definition: IOVarBase.h:397
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8, T9 s9)
Definition: IOVarBase.h:118
IO::IOVarBase::Write
bool Write(const Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7)
Definition: IOVarBase.h:277
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3, T4 s4, T5 s5, T6 s6, T7 s7, T8 s8)
Definition: IOVarBase.h:134
IO::IOVarBase::Read
bool Read(T &val)
Read functions ///.
Definition: IOVar.h:27
IO::IOVarBase::GetRank
virtual int GetRank()=0
IO::IOVarBase::Read
bool Read(Array< T, RANK > &val, T0 s0, T1 s1, T2 s2, T3 s3)
Definition: IOVarBase.h:181
IO::IOVarBase::Resize
virtual void Resize(int n)=0
Resizes the first dimension of the variable.