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  pfile.read(reinterpret_cast< char* >(data_ptr), dsize * sizeof(XValueType));
230  }
231  else
232  {
233  //otherwise stream the mult-dim array data generically
234  for(size_t i = 0; i < dsize; i++)
235  {
236  s >> data_ptr[i];
237  }
238  }
239  }
240 
241  virtual MHO_UUID DetermineTypeUUID() const override
242  {
243  MHO_MD5HashGenerator gen;
244  gen.Initialize();
245  std::string name = MHO_ClassIdentity::ClassName(*this);
246  gen << name;
247  gen.Finalize();
248  return gen.GetDigestAsUUID();
249  }
250 };
251 
253 //enumerate all of the table container types we might possibly use, this is not
254 //an exhaustive list and many other basic (POD)-based types are possible, if they
255 //are POD-based then additions should be listed here. If there are there are additional
256 //table container types which involve complicated classes or structs (which would
257 //would require an '#include' in this file, then they should be defined elsewhere.
258 //Since we are manily concerned with data (visibility and or cal) we only define
259 //tables for the following types:
260 
261 using Int = int;
262 using Double = double;
263 using ComplexD = std::complex< double >;
264 using ComplexF = std::complex< float >;
265 
266 #define DefTableContainers(TYPE) \
267  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int >; \
268  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double = MHO_TableContainer< TYPE, MHO_AxisPack_Double >; \
269  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String = MHO_TableContainer< TYPE, MHO_AxisPack_String >; \
270  \
271  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int >; \
272  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double >; \
273  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String = MHO_TableContainer< TYPE, MHO_AxisPack_Int_String >; \
274  \
275  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int >; \
276  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double = MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double >; \
277  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String = MHO_TableContainer< TYPE, MHO_AxisPack_Double_String >; \
278  \
279  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int = MHO_TableContainer< TYPE, MHO_AxisPack_String_Int >; \
280  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double = MHO_TableContainer< TYPE, MHO_AxisPack_String_Double >; \
281  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String = MHO_TableContainer< TYPE, MHO_AxisPack_String_String >; \
282  \
283  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Int >; \
284  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Double = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Double >; \
285  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_String = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_String >; \
286  \
287  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Int >; \
288  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Double = \
289  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Double >; \
290  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_String = \
291  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_String >; \
292  \
293  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Int >; \
294  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Double = \
295  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Double >; \
296  using MHO_TableContainer_##TYPE##_MHO_Int_AxisPack_String_String = \
297  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_String >; \
298  \
299  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Int >; \
300  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Double = \
301  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Double >; \
302  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_String = \
303  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_String >; \
304  \
305  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Int = \
306  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Int >; \
307  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Double = \
308  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Double >; \
309  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_String = \
310  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_String >; \
311  \
312  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Int = \
313  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Int >; \
314  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Double = \
315  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Double >; \
316  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_String = \
317  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_String >; \
318  \
319  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Int >; \
320  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Double = \
321  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Double >; \
322  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_String = \
323  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_String >; \
324  \
325  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Int = \
326  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Int >; \
327  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Double = \
328  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Double >; \
329  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_String = \
330  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_String >; \
331  \
332  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Int = \
333  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Int >; \
334  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Double = \
335  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Double >; \
336  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_String = \
337  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_String >; \
338  \
339  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Int_Int = MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Int_Int >; \
340  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Int_Double = \
341  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Int_Double >; \
342  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Int_String = \
343  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Int_String >; \
344  \
345  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Double_Int = \
346  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Double_Int >; \
347  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Double_Double = \
348  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Double_Double >; \
349  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_Double_String = \
350  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_Double_String >; \
351  \
352  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_String_Int = \
353  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_String_Int >; \
354  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Int_String_Double = \
355  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_String_Double >; \
356  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_String = \
357  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Int_String_String >; \
358  \
359  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Int_Int = \
360  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Int_Int >; \
361  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Int_Double = \
362  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Int_Double >; \
363  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Int_String = \
364  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Int_String >; \
365  \
366  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Double_Int = \
367  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Double_Int >; \
368  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Double_Double = \
369  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Double_Double >; \
370  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_Double_String = \
371  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_Double_String >; \
372  \
373  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_String_Int = \
374  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_String_Int >; \
375  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_String_Double = \
376  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_String_Double >; \
377  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_Double_String_String = \
378  MHO_TableContainer< TYPE, MHO_AxisPack_Int_Double_String_String >; \
379  \
380  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Int_Int = \
381  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Int_Int >; \
382  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Int_Double = \
383  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Int_Double >; \
384  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Int_String = \
385  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Int_String >; \
386  \
387  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Double_Int = \
388  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Double_Int >; \
389  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Double_Double = \
390  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Double_Double >; \
391  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_Double_String = \
392  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_Double_String >; \
393  \
394  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_String_Int = \
395  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_String_Int >; \
396  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_String_Double = \
397  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_String_Double >; \
398  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Int_String_String_String = \
399  MHO_TableContainer< TYPE, MHO_AxisPack_Int_String_String_String >; \
400  \
401  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Int_Int = \
402  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Int_Int >; \
403  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Int_Double = \
404  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Int_Double >; \
405  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Int_String = \
406  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Int_String >; \
407  \
408  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Double_Int = \
409  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Double_Int >; \
410  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Double_Double = \
411  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Double_Double >; \
412  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_Double_String = \
413  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_Double_String >; \
414  \
415  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_String_Int = \
416  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_String_Int >; \
417  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_String_Double = \
418  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_String_Double >; \
419  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Int_String_String = \
420  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Int_String_String >; \
421  \
422  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Int_Int = \
423  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Int_Int >; \
424  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Int_Double = \
425  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Int_Double >; \
426  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Int_String = \
427  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Int_String >; \
428  \
429  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Double_Int = \
430  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Double_Int >; \
431  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Double_Double = \
432  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Double_Double >; \
433  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_Double_String = \
434  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_Double_String >; \
435  \
436  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_String_Int = \
437  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_String_Int >; \
438  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_String_Double = \
439  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_String_Double >; \
440  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_Double_String_String = \
441  MHO_TableContainer< TYPE, MHO_AxisPack_Double_Double_String_String >; \
442  \
443  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Int_Int = \
444  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Int_Int >; \
445  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Int_Double = \
446  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Int_Double >; \
447  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Int_String = \
448  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Int_String >; \
449  \
450  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Double_Int = \
451  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Double_Int >; \
452  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Double_Double = \
453  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Double_Double >; \
454  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_Double_String = \
455  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_Double_String >; \
456  \
457  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_String_Int = \
458  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_String_Int >; \
459  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_String_Double = \
460  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_String_Double >; \
461  using MHO_TableContainer_##TYPE##_MHO_AxisPack_Double_String_String_String = \
462  MHO_TableContainer< TYPE, MHO_AxisPack_Double_String_String_String >; \
463  \
464  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Int_Int = \
465  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Int_Int >; \
466  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Int_Double = \
467  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Int_Double >; \
468  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Int_String = \
469  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Int_String >; \
470  \
471  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Double_Int = \
472  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Double_Int >; \
473  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Double_Double = \
474  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Double_Double >; \
475  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_Double_String = \
476  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_Double_String >; \
477  \
478  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_String_Int = \
479  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_String_Int >; \
480  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_String_Double = \
481  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_String_Double >; \
482  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Int_String_String = \
483  MHO_TableContainer< TYPE, MHO_AxisPack_String_Int_String_String >; \
484  \
485  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Int_Int = \
486  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Int_Int >; \
487  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Int_Double = \
488  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Int_Double >; \
489  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Int_String = \
490  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Int_String >; \
491  \
492  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Double_Int = \
493  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Double_Int >; \
494  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Double_Double = \
495  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Double_Double >; \
496  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_Double_String = \
497  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_Double_String >; \
498  \
499  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_String_Int = \
500  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_String_Int >; \
501  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_String_Double = \
502  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_String_Double >; \
503  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_Double_String_String = \
504  MHO_TableContainer< TYPE, MHO_AxisPack_String_Double_String_String >; \
505  \
506  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Int_Int = \
507  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Int_Int >; \
508  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Int_Double = \
509  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Int_Double >; \
510  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Int_String = \
511  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Int_String >; \
512  \
513  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Double_Int = \
514  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Double_Int >; \
515  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Double_Double = \
516  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Double_Double >; \
517  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_Double_String = \
518  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_Double_String >; \
519  \
520  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_String_Int = \
521  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_String_Int >; \
522  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_String_Double = \
523  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_String_Double >; \
524  using MHO_TableContainer_##TYPE##_MHO_AxisPack_String_String_String_String = \
525  MHO_TableContainer< TYPE, MHO_AxisPack_String_String_String_String >;
526 
527 DefTableContainers(Int);
528 DefTableContainers(Double);
529 DefTableContainers(ComplexD);
530 DefTableContainers(ComplexF);
531 
532 } // namespace hops
533 
534 #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:264
hops::Double
double Double
Definition: MHO_AxisPack.hh:217
hops::ComplexD
std::complex< double > ComplexD
Definition: MHO_TableContainer.hh:263
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 Thu Jun 18 2026 20:58:26 for HOPS by doxygen 1.9.1