HOPS
HOPS class reference
MHO_TableContainer.hh
Go to the documentation of this file.
1 #ifndef MHO_TableContainer_HH__
2 #define MHO_TableContainer_HH__
3 
4 #include <string>
5 #include <tuple>
6 #include <utility>
7 
8 #include "MHO_Axis.hh"
9 #include "MHO_AxisPack.hh"
10 #include "MHO_Meta.hh"
11 #include "MHO_NDArrayWrapper.hh"
12 #include "MHO_VectorContainer.hh"
13 
14 #include "MHO_FileStreamer.hh"
15 
16 namespace hops
17 {
18 
31 template< typename XValueType, typename XAxisPackType >
32 class MHO_TableContainer: public MHO_TableContainerBase,
33  public MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >,
34  public XAxisPackType,
35  public MHO_Taggable
36 {
37  public:
38  MHO_TableContainer(): MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >(), XAxisPackType(){};
39 
40  MHO_TableContainer(const std::size_t* dim)
41  : MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >(dim), XAxisPackType(dim){};
42 
43  //copy constructor
44  MHO_TableContainer(const MHO_TableContainer& obj)
45  : MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >(obj), XAxisPackType(obj), MHO_Taggable(obj){};
46 
52  MHO_TableContainer* Clone() { return new MHO_TableContainer(*this); }
53 
59  MHO_TableContainer* CloneEmpty() { return new MHO_TableContainer(this->GetDimensions()); }
60 
61  virtual ~MHO_TableContainer(){};
62 
69  virtual MHO_ClassVersion GetVersion() const override { return 0; };
70 
77  virtual uint64_t GetSerializedSize() const override
78  {
79  uint64_t total_size = 0;
80  total_size += sizeof(MHO_ClassVersion);
81  total_size += XAxisPackType::NAXES::value * sizeof(uint64_t);
82  total_size += XAxisPackType::GetSerializedSize();
83  total_size += MHO_Taggable::GetSerializedSize();
84  total_size += (this->GetSize()) * sizeof(XValueType);
85  return total_size;
86  }
87 
88  using XAxisPackType::resize_axis_pack;
89 
96  virtual void Resize(const std::size_t* dim) override
97  {
98  MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::Resize(dim);
99  resize_axis_pack(dim);
100  }
101 
107  XAxisPackType* GetAxisPack() { return this; }
108 
114  const XAxisPackType* GetAxisPack() const { return this; }
115 
116  //have to make base class functions visible
117  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::Resize;
118  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetData;
119  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetSize;
120  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetDimensions;
121  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetDimension;
122  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetDimensionArray;
123  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetOffsetForIndices;
124  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetIndicesForOffset;
125  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::SubView;
126  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::SliceView;
127 
128  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::at;
129  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::operator();
130  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::operator[];
131  using MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::ValueAt;
132 
133  //expensive copy (as opposed to the assignment operator,
134  //pointers to exernally managed memory are not transferred)
135  virtual void Copy(const MHO_TableContainer& rhs)
136  {
137  if(&rhs != this)
138  {
139  //copy the array
140  MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::Copy(rhs);
141  //copy the axis pack
142  *(this->GetAxisPack()) = *(rhs.GetAxisPack());
143  //finally copy the table tags
144  this->CopyTags(rhs);
145  }
146  }
147 
148  public:
149  template< typename XStream > friend XStream& operator>>(XStream& s, MHO_TableContainer& aData)
150  {
151  MHO_ClassVersion vers;
152  s >> vers;
153 
154  switch(vers)
155  {
156  case 0:
157  aData.StreamInData_V0(s);
158  break;
159  default:
160  MHO_ClassIdentity::ClassVersionErrorMsg(aData, vers);
161  //Flag this as an unknown object version so we can skip over this data
162  MHO_ObjectStreamState< XStream >::SetUnknown(s);
163  }
164  return s;
165  }
166 
167  template< typename XStream > friend XStream& operator<<(XStream& s, const MHO_TableContainer& aData)
168  {
169  switch(aData.GetVersion())
170  {
171  case 0:
172  s << aData.GetVersion();
173  aData.StreamOutData_V0(s);
174  break;
175  default:
176  msg_error("containers", "error, cannot stream out MHO_TableContainer object with unknown version: "
177  << aData.GetVersion() << eom);
178  }
179  return s;
180  }
181 
182  private:
183  template< typename XStream > void StreamOutData_V0(XStream& s) const
184  {
185  //first stream version and dimensions
186  s << static_cast< const MHO_Taggable& >(*this);
187  auto dims = this->GetDimensionArray();
188  for(size_t i = 0; i < XAxisPackType::NAXES::value; i++)
189  {
190  s << (uint64_t)dims[i];
191  }
192  //then dump axes
193  s << static_cast< const XAxisPackType& >(*this);
194 
195  //finally dump the array data
196  std::size_t dsize = this->GetSize();
197  auto data_ptr = this->GetData();
198  for(size_t i = 0; i < dsize; i++)
199  {
200  s << data_ptr[i];
201  }
202  }
203 
204  template< typename XStream > void StreamInData_V0(XStream& s)
205  {
206  s >> static_cast< MHO_Taggable& >(*this);
207 
208  //next stream the axis-pack
209  uint64_t tmp_dim;
210  std::size_t dims[XAxisPackType::NAXES::value];
211  for(size_t i = 0; i < XAxisPackType::NAXES::value; i++)
212  {
213  s >> tmp_dim;
214  dims[i] = tmp_dim;
215  }
216  this->Resize(dims);
217 
218  //now stream in the axes
219  s >> static_cast< XAxisPackType& >(*this);
220 
221  //ask for the file stream directly so we can optimize the read in chunks
222  //this is not so bueno, breaking ecapsulation of the file streamer class
223  auto fs_ptr = dynamic_cast< MHO_FileStreamer* >(&s);
224  std::size_t dsize = this->GetSize();
225  auto data_ptr = this->GetData();
226  if(fs_ptr != nullptr)
227  {
228  std::fstream& pfile = fs_ptr->GetStream();
229  std::size_t nbytes = dsize * sizeof(XValueType);
230  pfile.read(reinterpret_cast< char* >(data_ptr), nbytes);
231  //check we didn't read a truncated/corrupt file
232  if(static_cast< std::size_t >(pfile.gcount()) != nbytes)
233  {
234  msg_error("containers", "error reading MHO_TableContainer data block, expected "
235  << nbytes << " bytes but read " << pfile.gcount()
236  << "; file may be truncated or corrupt." << eom);
237  }
238  }
239  else
240  {
241  //otherwise stream the mult-dim array data generically
242  for(size_t i = 0; i < dsize; i++)
243  {
244  s >> data_ptr[i];
245  }
246  }
247  }
248 
249  virtual MHO_UUID DetermineTypeUUID() const override
250  {
251  MHO_MD5HashGenerator gen;
252  gen.Initialize();
253  std::string name = MHO_ClassIdentity::ClassName(*this);
254  gen << name;
255  gen.Finalize();
256  return gen.GetDigestAsUUID();
257  }
258 };
259 
261 //enumerate all of the table container types we might possibly use, this is not
262 //an exhaustive list and many other basic (POD)-based types are possible, if they
263 //are POD-based then additions should be listed here. If there are there are additional
264 //table container types which involve complicated classes or structs (which would
265 //would require an '#include' in this file, then they should be defined elsewhere.
266 //Since we are manily concerned with data (visibility and or cal) we only define
267 //tables for the following types:
268 
269 using Int = int;
270 using Double = double;
271 using ComplexD = std::complex< double >;
272 using ComplexF = std::complex< float >;
273 
274 #define DefTableContainers(TYPE) \
275  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int >; \
276  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double = MHO_TableContainer< TYPE, MHO_AxisPack_Double >; \
277  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String = MHO_TableContainer< TYPE, MHO_AxisPack_String >; \
278  \
279  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int >; \
280  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double >; \
281  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String = MHO_TableContainer< TYPE, MHO_AxisPack_Int_String >; \
282  \
283  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int >; \
284  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double = MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double >; \
285  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String = MHO_TableContainer< TYPE, MHO_AxisPack_Double_String >; \
286  \
287  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int = MHO_TableContainer< TYPE, MHO_AxisPack_String_Int >; \
288  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double = MHO_TableContainer< TYPE, MHO_AxisPack_String_Double >; \
289  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String = MHO_TableContainer< TYPE, MHO_AxisPack_String_String >; \
290  \
291  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Int >; \
292  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Double = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Double >; \
293  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_String = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_String >; \
294  \
295  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Int >; \
296  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Double = \
297  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Double >; \
298  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_String = \
299  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_String >; \
300  \
301  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Int >; \
302  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Double = \
303  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Double >; \
304  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_String = \
305  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_String >; \
306  \
307  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Int >; \
308  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Double = \
309  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Double >; \
310  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_String = \
311  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_String >; \
312  \
313  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Int = \
314  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Int >; \
315  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Double = \
316  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Double >; \
317  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_String = \
318  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_String >; \
319  \
320  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Int = \
321  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Int >; \
322  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Double = \
323  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Double >; \
324  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_String = \
325  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_String >; \
326  \
327  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Int >; \
328  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Double = \
329  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Double >; \
330  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_String = \
331  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_String >; \
332  \
333  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Int = \
334  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Int >; \
335  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Double = \
336  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Double >; \
337  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_String = \
338  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_String >; \
339  \
340  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Int = \
341  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Int >; \
342  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Double = \
343  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Double >; \
344  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_String = \
345  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_String >; \
346  \
347  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Int_Int >; \
348  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Int_Double = \
349  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Int_Double >; \
350  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Int_String = \
351  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Int_String >; \
352  \
353  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Double_Int = \
354  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Double_Int >; \
355  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Double_Double = \
356  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Double_Double >; \
357  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Double_String = \
358  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Double_String >; \
359  \
360  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_String_Int = \
361  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_String_Int >; \
362  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_String_Double = \
363  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_String_Double >; \
364  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_String_String = \
365  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_String_String >; \
366  \
367  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Int_Int = \
368  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Int_Int >; \
369  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Int_Double = \
370  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Int_Double >; \
371  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Int_String = \
372  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Int_String >; \
373  \
374  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Double_Int = \
375  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Double_Int >; \
376  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Double_Double = \
377  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Double_Double >; \
378  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Double_String = \
379  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Double_String >; \
380  \
381  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_String_Int = \
382  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_String_Int >; \
383  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_String_Double = \
384  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_String_Double >; \
385  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_String_String = \
386  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_String_String >; \
387  \
388  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Int_Int = \
389  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Int_Int >; \
390  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Int_Double = \
391  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Int_Double >; \
392  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Int_String = \
393  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Int_String >; \
394  \
395  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Double_Int = \
396  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Double_Int >; \
397  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Double_Double = \
398  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Double_Double >; \
399  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Double_String = \
400  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Double_String >; \
401  \
402  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_String_Int = \
403  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_String_Int >; \
404  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_String_Double = \
405  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_String_Double >; \
406  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_String_String = \
407  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_String_String >; \
408  \
409  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Int_Int = \
410  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Int_Int >; \
411  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Int_Double = \
412  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Int_Double >; \
413  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Int_String = \
414  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Int_String >; \
415  \
416  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Double_Int = \
417  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Double_Int >; \
418  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Double_Double = \
419  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Double_Double >; \
420  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Double_String = \
421  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Double_String >; \
422  \
423  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_String_Int = \
424  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_String_Int >; \
425  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_String_Double = \
426  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_String_Double >; \
427  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_String_String = \
428  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_String_String >; \
429  \
430  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Int_Int = \
431  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Int_Int >; \
432  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Int_Double = \
433  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Int_Double >; \
434  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Int_String = \
435  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Int_String >; \
436  \
437  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Double_Int = \
438  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Double_Int >; \
439  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Double_Double = \
440  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Double_Double >; \
441  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Double_String = \
442  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Double_String >; \
443  \
444  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_String_Int = \
445  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_String_Int >; \
446  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_String_Double = \
447  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_String_Double >; \
448  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_String_String = \
449  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_String_String >; \
450  \
451  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Int_Int = \
452  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Int_Int >; \
453  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Int_Double = \
454  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Int_Double >; \
455  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Int_String = \
456  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Int_String >; \
457  \
458  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Double_Int = \
459  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Double_Int >; \
460  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Double_Double = \
461  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Double_Double >; \
462  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Double_String = \
463  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Double_String >; \
464  \
465  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_String_Int = \
466  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_String_Int >; \
467  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_String_Double = \
468  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_String_Double >; \
469  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_String_String = \
470  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_String_String >; \
471  \
472  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Int_Int = \
473  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Int_Int >; \
474  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Int_Double = \
475  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Int_Double >; \
476  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Int_String = \
477  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Int_String >; \
478  \
479  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Double_Int = \
480  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Double_Int >; \
481  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Double_Double = \
482  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Double_Double >; \
483  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Double_String = \
484  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Double_String >; \
485  \
486  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_String_Int = \
487  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_String_Int >; \
488  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_String_Double = \
489  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_String_Double >; \
490  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_String_String = \
491  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_String_String >; \
492  \
493  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Int_Int = \
494  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Int_Int >; \
495  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Int_Double = \
496  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Int_Double >; \
497  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Int_String = \
498  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Int_String >; \
499  \
500  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Double_Int = \
501  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Double_Int >; \
502  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Double_Double = \
503  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Double_Double >; \
504  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Double_String = \
505  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Double_String >; \
506  \
507  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_String_Int = \
508  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_String_Int >; \
509  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_String_Double = \
510  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_String_Double >; \
511  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_String_String = \
512  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_String_String >; \
513  \
514  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Int_Int = \
515  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Int_Int >; \
516  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Int_Double = \
517  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Int_Double >; \
518  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Int_String = \
519  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Int_String >; \
520  \
521  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Double_Int = \
522  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Double_Int >; \
523  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Double_Double = \
524  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Double_Double >; \
525  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Double_String = \
526  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Double_String >; \
527  \
528  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_String_Int = \
529  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_String_Int >; \
530  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_String_Double = \
531  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_String_Double >; \
532  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_String_String = \
533  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_String_String >;
534 
535 DefTableContainers(Int);
536 DefTableContainers(Double);
537 DefTableContainers(ComplexD);
538 DefTableContainers(ComplexF);
539 
540 } // namespace hops
541 
542 #endif
MHO_AxisPack.hh
MHO_Axis.hh
MHO_FileStreamer.hh
msg_error
#define msg_error(xKEY, xCONTENT)
Definition: MHO_Message.hh:238
MHO_Meta.hh
template meta-programming helper functions, mostly tuple access/modification
MHO_NDArrayWrapper.hh
MHO_VectorContainer.hh
hops::MHO_NDArrayWrapper
Class MHO_NDArrayWrapper.
Definition: MHO_NDArrayWrapper.hh:42
hops::MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetSize
std::size_t GetSize() const
get the total size of the array
Definition: MHO_NDArrayWrapper.hh:119
hops::MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetData
XValueType * GetData()
access to underlying data pointer (unsafe)
Definition: MHO_NDArrayWrapper.hh:262
hops::MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetDimensions
const std::size_t * GetDimensions() const
get the dimensions/shape of the array
Definition: MHO_NDArrayWrapper.hh:126
hops::MHO_NDArrayWrapper::Resize
virtual void Resize(const std::size_t *dim)
Destroys contents and resizes using passed dimensions.
Definition: MHO_NDArrayWrapper.hh:83
hops::MHO_NDArrayWrapper< XValueType, XAxisPackType::NAXES::value >::GetDimensionArray
index_type GetDimensionArray() const
Getter for dimension array.
Definition: MHO_NDArrayWrapper.hh:146
hops::MHO_NDArrayWrapper::Copy
virtual void Copy(const MHO_NDArrayWrapper &rhs)
Definition: MHO_NDArrayWrapper.hh:301
hops::MHO_TableContainerBase
Definition: MHO_Meta.hh:411
hops::MHO_TableContainer
Class MHO_TableContainer.
Definition: MHO_TableContainer.hh:36
hops::MHO_TableContainer::MHO_TableContainer
MHO_TableContainer(const MHO_TableContainer &obj)
Definition: MHO_TableContainer.hh:44
hops::MHO_TableContainer::MHO_TableContainer
MHO_TableContainer(const std::size_t *dim)
Definition: MHO_TableContainer.hh:40
hops::MHO_TableContainer::Resize
virtual void Resize(const std::size_t *dim) override
Resize the multidimensional array and axes according to given dimensions.
Definition: MHO_TableContainer.hh:96
hops::MHO_TableContainer::~MHO_TableContainer
virtual ~MHO_TableContainer()
Definition: MHO_TableContainer.hh:61
hops::MHO_TableContainer::MHO_TableContainer
MHO_TableContainer()
Definition: MHO_TableContainer.hh:38
hops::MHO_TableContainer::GetVersion
virtual MHO_ClassVersion GetVersion() const override
Getter for the class version.
Definition: MHO_TableContainer.hh:69
hops::MHO_TableContainer::GetAxisPack
XAxisPackType * GetAxisPack()
access to axis pack type alone
Definition: MHO_TableContainer.hh:107
hops::MHO_TableContainer::operator<<
friend XStream & operator<<(XStream &s, const MHO_TableContainer &aData)
Definition: MHO_TableContainer.hh:167
hops::MHO_TableContainer::Clone
MHO_TableContainer * Clone()
Clones entire table including contents and axes.
Definition: MHO_TableContainer.hh:52
hops::MHO_TableContainer::CloneEmpty
MHO_TableContainer * CloneEmpty()
Clones table container shape with empty contents and axes.
Definition: MHO_TableContainer.hh:59
hops::MHO_TableContainer::Copy
virtual void Copy(const MHO_TableContainer &rhs)
Definition: MHO_TableContainer.hh:135
hops::MHO_TableContainer::operator>>
friend XStream & operator>>(XStream &s, MHO_TableContainer &aData)
Definition: MHO_TableContainer.hh:149
hops::MHO_TableContainer::GetSerializedSize
virtual uint64_t GetSerializedSize() const override
Getter for serialized size.
Definition: MHO_TableContainer.hh:77
hops::MHO_TableContainer::GetAxisPack
const XAxisPackType * GetAxisPack() const
Getter for axis pack.
Definition: MHO_TableContainer.hh:114
hops::MHO_Taggable
Class MHO_Taggable.
Definition: MHO_Taggable.hh:26
hops::MHO_Taggable::MHO_Taggable
MHO_Taggable()
Definition: MHO_Taggable.hh:28
hops::MHO_Taggable::CopyTags
virtual void CopyTags(const MHO_Taggable &rhs)
Copies tags from rhs to this instance if rhs is not empty and has valid object.
Definition: MHO_Taggable.hh:49
hops::MHO_Taggable::GetSerializedSize
virtual uint64_t GetSerializedSize() const override
Getter for serialized size.
Definition: MHO_Taggable.hh:120
hops
Definition: MHO_AdhocFlagging.hh:18
hops::Int
int Int
Definition: MHO_AxisPack.hh:216
hops::MHO_ClassVersion
uint32_t MHO_ClassVersion
Definition: MHO_ClassIdentity.hh:22
hops::DefTableContainers
DefTableContainers(Int)
hops::ComplexF
std::complex< float > ComplexF
Definition: MHO_TableContainer.hh:272
hops::Double
double Double
Definition: MHO_AxisPack.hh:217
hops::ComplexD
std::complex< double > ComplexD
Definition: MHO_TableContainer.hh:271
hops::MHO_ClassIdentity::ClassVersionErrorMsg
static void ClassVersionErrorMsg(const XClassType &obj, MHO_ClassVersion version)
Generates an error message for when an unknown or unsupported class version is encountered.
Definition: MHO_ClassIdentity.hh:112
hops::MHO_ClassIdentity::ClassName
static std::string ClassName()
Returns the class name as a string.
Definition: MHO_ClassIdentity.hh:51
hops::MHO_ObjectStreamState::SetUnknown
static void SetUnknown(XStreamType &)
Setter for unknown.
Definition: MHO_FileStreamer.hh:214
value
Definition: vex.h:175
Generated on Mon Aug 3 2026 18:26:01 for HOPS by doxygen 1.9.1