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