CYCLUS
hdf5_back.cc
Go to the documentation of this file.
1 #include "hdf5_back.h"
2 
3 #include <cmath>
4 #include <string.h>
5 #include <iostream>
6 
7 #include "blob.h"
8 
9 namespace cyclus {
10 
11 Hdf5Back::Hdf5Back(std::string path) : path_(path) {
12  H5open();
13  hasher_.Clear();
14  if (boost::filesystem::exists(path_))
15  file_ = H5Fopen(path_.c_str(), H5F_ACC_RDWR, H5P_DEFAULT);
16  else
17  file_ = H5Fcreate(path_.c_str(), H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
18  opened_types_.clear();
19  vldatasets_.clear();
20  vldts_.clear();
21  vlkeys_.clear();
22 
23  uuid_type_ = H5Tcopy(H5T_C_S1);
24  H5Tset_size(uuid_type_, CYCLUS_UUID_SIZE);
25  H5Tset_strpad(uuid_type_, H5T_STR_NULLPAD);
26  opened_types_.insert(uuid_type_);
27 
28  hsize_t sha1_len = CYCLUS_SHA1_NINT; // 160 bits == 32 bits / int * 5 ints
29  sha1_type_ = H5Tarray_create2(H5T_NATIVE_UINT, 1, &sha1_len);
30  opened_types_.insert(sha1_type_);
31 
32  vlstr_type_ = H5Tcopy(H5T_C_S1);
33  H5Tset_size(vlstr_type_, H5T_VARIABLE);
34  opened_types_.insert(vlstr_type_);
35  vldts_[VL_STRING] = vlstr_type_;
36 
37  blob_type_ = vlstr_type_;
38  vldts_[BLOB] = blob_type_;
39 }
40 
42  // make sure we are still open
43  if (closed_)
44  return;
45 
46  // cleanup HDF5
47  Flush();
48  H5Fclose(file_);
49  std::set<hid_t>::iterator t;
50  for (t = opened_types_.begin(); t != opened_types_.end(); ++t)
51  H5Tclose(*t);
52  std::map<std::string, hid_t>::iterator vldsit;
53  for (vldsit = vldatasets_.begin(); vldsit != vldatasets_.end(); ++vldsit)
54  H5Dclose(vldsit->second);
55 
56  // cleanup memory
57  std::map<std::string, size_t*>::iterator it;
58  std::map<std::string, DbTypes*>::iterator dbtit;
59  for (it = col_offsets_.begin(); it != col_offsets_.end(); ++it) {
60  delete[](it->second);
61  }
62  for (it = col_sizes_.begin(); it != col_sizes_.end(); ++it) {
63  delete[](it->second);
64  }
65  for (dbtit = schemas_.begin(); dbtit != schemas_.end(); ++dbtit) {
66  delete[](dbtit->second);
67  }
68 
69  closed_ = true;
70 }
71 
73  if (!closed_)
74  Close();
75 }
76 
78  std::map<std::string, DatumList> groups;
79  for (DatumList::iterator it = data.begin(); it != data.end(); ++it) {
80  std::string name = (*it)->title();
81  if (schema_sizes_.count(name) == 0) {
82  if (H5Lexists(file_, name.c_str(), H5P_DEFAULT)) {
83  LoadTableTypes(name, (*it)->vals().size(), *it);
84  } else {
85  // Datum* d = *it;
86  // CreateTable(d);
87  CreateTable(*it);
88  }
89  }
90  groups[name].push_back(*it);
91  }
92 
93  std::map<std::string, DatumList>::iterator it;
94  for (it = groups.begin(); it != groups.end(); ++it) {
95  WriteGroup(it->second);
96  }
97 }
98 
99 template <>
100 std::string Hdf5Back::VLRead<std::string, VL_STRING>(const char* rawkey) {
101  using std::string;
102  // key is used as offset
103  Digest key;
104  memcpy(key.val, rawkey, CYCLUS_SHA1_SIZE);
105  const std::vector<hsize_t> idx = key.cast<hsize_t>();
106  hid_t dset = VLDataset(VL_STRING, false);
107  hid_t dspace = H5Dget_space(dset);
108  hid_t mspace = H5Screate_simple(CYCLUS_SHA1_NINT, vlchunk_, NULL);
109  herr_t status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET,
110  (const hsize_t*) &idx[0],
111  NULL, vlchunk_, NULL);
112  if (status < 0)
113  throw IOError("could not select hyperslab of string value array for reading "
114  "in the database '" + path_ + "'.");
115  char** buf = new char*[sizeof(char *)];
116  status = H5Dread(dset, vldts_[VL_STRING], mspace, dspace, H5P_DEFAULT, buf);
117  if (status < 0)
118  throw IOError("failed to read in variable length string data "
119  "in database '" + path_ + "'.");
120  string val;
121  if (buf[0] != NULL)
122  val = string(buf[0]);
123  status = H5Dvlen_reclaim(vldts_[VL_STRING], mspace, H5P_DEFAULT, buf);
124  if (status < 0)
125  throw IOError("failed to reclaim variable length string data space in "
126  "database '" + path_ + "'.");
127  delete[] buf;
128  H5Sclose(mspace);
129  H5Sclose(dspace);
130  return val;
131 }
132 
133 template <>
134 Blob Hdf5Back::VLRead<Blob, BLOB>(const char* rawkey) {
135  // key is used as offset
136  Digest key;
137  memcpy(key.val, rawkey, CYCLUS_SHA1_SIZE);
138  const std::vector<hsize_t> idx = key.cast<hsize_t>();
139  hid_t dset = VLDataset(BLOB, false);
140  hid_t dspace = H5Dget_space(dset);
141  hid_t mspace = H5Screate_simple(CYCLUS_SHA1_NINT, vlchunk_, NULL);
142  herr_t status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET,
143  (const hsize_t*) &idx[0],
144  NULL, vlchunk_, NULL);
145  if (status < 0)
146  throw IOError("could not select hyperslab of Blob value array for reading "
147  "in the database '" + path_ + "'.");
148  char** buf = new char*[sizeof(char *)];
149  status = H5Dread(dset, vldts_[BLOB], mspace, dspace, H5P_DEFAULT, buf);
150  if (status < 0)
151  throw IOError("failed to read in Blob data in database '" + path_ + "'.");
152  Blob val = Blob(buf[0]);
153  status = H5Dvlen_reclaim(vldts_[BLOB], mspace, H5P_DEFAULT, buf);
154  if (status < 0)
155  throw IOError("failed to reclaim Blob data space in database "
156  "'" + path_ + "'.");
157  delete[] buf;
158  H5Sclose(mspace);
159  H5Sclose(dspace);
160  return val;
161 }
162 
163 QueryResult Hdf5Back::Query(std::string table, std::vector<Cond>* conds) {
164  using std::string;
165  using std::vector;
166  using std::set;
167  using std::list;
168  using std::pair;
169  using std::map;
170  if (!H5Lexists(file_, table.c_str(), H5P_DEFAULT))
171  throw IOError("table '" + table + "' does not exist in '" + path_ + "'.");
172  int i;
173  int j;
174  int jlen;
175  herr_t status = 0;
176  hid_t tb_set = H5Dopen2(file_, table.c_str(), H5P_DEFAULT);
177  hid_t tb_space = H5Dget_space(tb_set);
178  hid_t tb_plist = H5Dget_create_plist(tb_set);
179  hid_t tb_type = H5Dget_type(tb_set);
180  size_t tb_typesize = H5Tget_size(tb_type);
181  int tb_length = H5Sget_simple_extent_npoints(tb_space);
182  hsize_t tb_chunksize;
183  H5Pget_chunk(tb_plist, 1, &tb_chunksize);
184  unsigned int nchunks =
185  (tb_length/tb_chunksize) + (tb_length%tb_chunksize == 0?0:1);
186 
187  // set up field-conditions map
188  std::map<std::string, std::vector<Cond*> > field_conds =
189  std::map<std::string, std::vector<Cond*> >();
190  if (conds != NULL) {
191  Cond* cond;
192  for (i = 0; i < conds->size(); ++i) {
193  cond = &((*conds)[i]);
194  if (field_conds.count(cond->field) == 0)
195  field_conds[cond->field] = std::vector<Cond*>();
196  field_conds[cond->field].push_back(cond);
197  }
198  }
199 
200  // read in data
201  QueryResult qr = GetTableInfo(table, tb_set, tb_type);
202  int nfields = qr.fields.size();
203  for (i = 0; i < nfields; ++i) {
204  if (field_conds.count(qr.fields[i]) == 0) {
205  field_conds[qr.fields[i]] = std::vector<Cond*>();
206  }
207  }
208  for (unsigned int n = 0; n < nchunks; ++n) {
209  // This loop is meant to be OpenMP-izable
210  hid_t field_type;
211  hsize_t start = n * tb_chunksize;
212  hsize_t count =
213  (tb_length-start) < tb_chunksize ? tb_length - start : tb_chunksize;
214  char* buf = new char[tb_typesize * count];
215  hid_t memspace = H5Screate_simple(1, &count, NULL);
216  status = H5Sselect_hyperslab(tb_space, H5S_SELECT_SET, &start, NULL,
217  &count, NULL);
218  status = H5Dread(tb_set, tb_type, memspace, tb_space, H5P_DEFAULT, buf);
219  int offset = 0;
220  bool is_row_selected;
221  for (i = 0; i < count; ++i) {
222  offset = i * tb_typesize;
223  is_row_selected = true;
224  QueryRow row = QueryRow(nfields);
225  for (j = 0; j < nfields; ++j) {
226  switch (qr.types[j]) {
227  case BOOL: {
228  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
229  unsigned int total_size0=H5Tget_size(fieldtype0);
230  bool x0;
231  x0=*reinterpret_cast<bool*>(buf+offset);
232  is_row_selected=CmpConds<bool>(&x0, &(field_conds[qr.fields[j]]));
233  if(is_row_selected){
234  row[j]=x0;
235 
236  }
237  H5Tclose(fieldtype0);
238  break;
239 
240  }
241  case INT: {
242  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
243  unsigned int total_size0=H5Tget_size(fieldtype0);
244  int x0;
245  x0=*reinterpret_cast<int*>(buf+offset);
246  is_row_selected=CmpConds<int>(&x0, &(field_conds[qr.fields[j]]));
247  if(is_row_selected){
248  row[j]=x0;
249 
250  }
251  H5Tclose(fieldtype0);
252  break;
253 
254  }
255  case FLOAT: {
256  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
257  unsigned int total_size0=H5Tget_size(fieldtype0);
258  float x0;
259  x0=*reinterpret_cast<float*>(buf+offset);
260  is_row_selected=CmpConds<float>(&x0, &(field_conds[qr.fields[j]]));
261  if(is_row_selected){
262  row[j]=x0;
263 
264  }
265  H5Tclose(fieldtype0);
266  break;
267 
268  }
269  case DOUBLE: {
270  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
271  unsigned int total_size0=H5Tget_size(fieldtype0);
272  double x0;
273  x0=*reinterpret_cast<double*>(buf+offset);
274  is_row_selected=CmpConds<double>(&x0, &(field_conds[qr.fields[j]]));
275  if(is_row_selected){
276  row[j]=x0;
277 
278  }
279  H5Tclose(fieldtype0);
280  break;
281 
282  }
283  case STRING: {
284  size_t nullpos0;
285  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
286  unsigned int total_size0=H5Tget_size(fieldtype0);
287  std::string x0;
288  x0=std::string(buf+offset, total_size0);
289  nullpos0=x0.find('\0');
290  if(nullpos0!=std::string::npos){
291  x0.resize(nullpos0);
292 
293  }
294  is_row_selected=CmpConds<std::string>(&x0, &(field_conds[qr.fields[j]]));
295  if(is_row_selected){
296  row[j]=x0;
297 
298  }
299  H5Tclose(fieldtype0);
300  break;
301 
302  }
303  case VL_STRING: {
304  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
305  unsigned int total_size0=H5Tget_size(fieldtype0);
306  std::string x0;
307  x0=VLRead<std::string,VL_STRING>(buf+offset);
308  is_row_selected=CmpConds<std::string>(&x0, &(field_conds[qr.fields[j]]));
309  if(is_row_selected){
310  row[j]=x0;
311 
312  }
313  H5Tclose(fieldtype0);
314  break;
315 
316  }
317  case BLOB: {
318  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
319  unsigned int total_size0=H5Tget_size(fieldtype0);
320  cyclus::Blob x0;
321  x0=VLRead<cyclus::Blob,BLOB>(buf+offset);
322  is_row_selected=CmpConds<cyclus::Blob>(&x0, &(field_conds[qr.fields[j]]));
323  if(is_row_selected){
324  row[j]=x0;
325 
326  }
327  H5Tclose(fieldtype0);
328  break;
329 
330  }
331  case UUID: {
332  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
333  unsigned int total_size0=H5Tget_size(fieldtype0);
334  boost::uuids::uuid x0;
335  memcpy(&x0, buf+offset, total_size0);
336  is_row_selected=CmpConds<boost::uuids::uuid>(&x0, &(field_conds[qr.fields[j]]));
337  if(is_row_selected){
338  row[j]=x0;
339 
340  }
341  H5Tclose(fieldtype0);
342  break;
343 
344  }
345  case VECTOR_INT: {
346  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
347  unsigned int total_size0=H5Tget_size(fieldtype0);
348  hsize_t fieldlen0;
349  H5Tget_array_dims2(fieldtype0, &fieldlen0);
350  hid_t item_type0=H5Tget_super(fieldtype0);
351  unsigned int total_size1elem=H5Tget_size(item_type0);
352  std::vector<int> x0;
353  x0=std::vector<int>(fieldlen0);
354  memcpy(&x0[0], buf+offset, total_size0);
355  is_row_selected=CmpConds<std::vector<int>>(&x0, &(field_conds[qr.fields[j]]));
356  if(is_row_selected){
357  row[j]=x0;
358 
359  }
360  H5Tclose(item_type0);
361  H5Tclose(fieldtype0);
362  break;
363 
364  }
365  case VL_VECTOR_INT: {
366  unsigned int total_size0=CYCLUS_SHA1_SIZE;
367  std::vector<int> x0;
368  x0=VLRead<std::vector<int>,VL_VECTOR_INT>(buf+offset);
369  is_row_selected=CmpConds<std::vector<int>>(&x0, &(field_conds[qr.fields[j]]));
370  if(is_row_selected){
371  row[j]=x0;
372 
373  }
374  break;
375 
376  }
377  case VECTOR_FLOAT: {
378  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
379  unsigned int total_size0=H5Tget_size(fieldtype0);
380  hsize_t fieldlen0;
381  H5Tget_array_dims2(fieldtype0, &fieldlen0);
382  hid_t item_type0=H5Tget_super(fieldtype0);
383  unsigned int total_size1elem=H5Tget_size(item_type0);
384  std::vector<float> x0;
385  x0=std::vector<float>(fieldlen0);
386  memcpy(&x0[0], buf+offset, total_size0);
387  is_row_selected=CmpConds<std::vector<float>>(&x0, &(field_conds[qr.fields[j]]));
388  if(is_row_selected){
389  row[j]=x0;
390 
391  }
392  H5Tclose(item_type0);
393  H5Tclose(fieldtype0);
394  break;
395 
396  }
397  case VL_VECTOR_FLOAT: {
398  unsigned int total_size0=CYCLUS_SHA1_SIZE;
399  std::vector<float> x0;
400  x0=VLRead<std::vector<float>,VL_VECTOR_FLOAT>(buf+offset);
401  is_row_selected=CmpConds<std::vector<float>>(&x0, &(field_conds[qr.fields[j]]));
402  if(is_row_selected){
403  row[j]=x0;
404 
405  }
406  break;
407 
408  }
409  case VECTOR_DOUBLE: {
410  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
411  unsigned int total_size0=H5Tget_size(fieldtype0);
412  hsize_t fieldlen0;
413  H5Tget_array_dims2(fieldtype0, &fieldlen0);
414  hid_t item_type0=H5Tget_super(fieldtype0);
415  unsigned int total_size1elem=H5Tget_size(item_type0);
416  std::vector<double> x0;
417  x0=std::vector<double>(fieldlen0);
418  memcpy(&x0[0], buf+offset, total_size0);
419  is_row_selected=CmpConds<std::vector<double>>(&x0, &(field_conds[qr.fields[j]]));
420  if(is_row_selected){
421  row[j]=x0;
422 
423  }
424  H5Tclose(item_type0);
425  H5Tclose(fieldtype0);
426  break;
427 
428  }
429  case VL_VECTOR_DOUBLE: {
430  unsigned int total_size0=CYCLUS_SHA1_SIZE;
431  std::vector<double> x0;
432  x0=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(buf+offset);
433  is_row_selected=CmpConds<std::vector<double>>(&x0, &(field_conds[qr.fields[j]]));
434  if(is_row_selected){
435  row[j]=x0;
436 
437  }
438  break;
439 
440  }
441  case VECTOR_STRING: {
442  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
443  unsigned int total_size0=H5Tget_size(fieldtype0);
444  hsize_t fieldlen0;
445  H5Tget_array_dims2(fieldtype0, &fieldlen0);
446  hid_t item_type0=H5Tget_super(fieldtype0);
447  size_t nullpos1elem;
448  unsigned int total_size1elem=H5Tget_size(item_type0);
449  std::vector<std::string> x0;
450  x0=std::vector<std::string>(fieldlen0);
451  for(unsigned int k0=0;k0<fieldlen0;++k0){
452  x0[k0]=std::string(buf+offset+total_size1elem*k0, total_size1elem);
453  nullpos1elem=x0[k0].find('\0');
454  if(nullpos1elem!=std::string::npos){
455  x0[k0].resize(nullpos1elem);
456 
457  }
458 
459  }
460  is_row_selected=CmpConds<std::vector<std::string>>(&x0, &(field_conds[qr.fields[j]]));
461  if(is_row_selected){
462  row[j]=x0;
463 
464  }
465  H5Tclose(item_type0);
466  H5Tclose(fieldtype0);
467  break;
468 
469  }
470  case VL_VECTOR_STRING: {
471  unsigned int total_size0=CYCLUS_SHA1_SIZE;
472  std::vector<std::string> x0;
473  x0=VLRead<std::vector<std::string>,VL_VECTOR_STRING>(buf+offset);
474  is_row_selected=CmpConds<std::vector<std::string>>(&x0, &(field_conds[qr.fields[j]]));
475  if(is_row_selected){
476  row[j]=x0;
477 
478  }
479  break;
480 
481  }
482  case VECTOR_VL_STRING: {
483  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
484  unsigned int total_size0=H5Tget_size(fieldtype0);
485  hsize_t fieldlen0;
486  H5Tget_array_dims2(fieldtype0, &fieldlen0);
487  hid_t item_type0=H5Tget_super(fieldtype0);
488  unsigned int total_size1elem=H5Tget_size(item_type0);
489  std::vector<std::string> x0;
490  x0=std::vector<std::string>(fieldlen0);
491  for(unsigned int k0=0;k0<fieldlen0;++k0){
492  std::string x1elem;
493  x1elem=VLRead<std::string,VL_STRING>(buf+offset+total_size1elem*k0);
494  x0[k0]=x1elem;
495 
496  }
497  is_row_selected=CmpConds<std::vector<std::string>>(&x0, &(field_conds[qr.fields[j]]));
498  if(is_row_selected){
499  row[j]=x0;
500 
501  }
502  H5Tclose(item_type0);
503  H5Tclose(fieldtype0);
504  break;
505 
506  }
507  case VL_VECTOR_VL_STRING: {
508  unsigned int total_size0=CYCLUS_SHA1_SIZE;
509  std::vector<std::string> x0;
510  x0=VLRead<std::vector<std::string>,VL_VECTOR_VL_STRING>(buf+offset);
511  is_row_selected=CmpConds<std::vector<std::string>>(&x0, &(field_conds[qr.fields[j]]));
512  if(is_row_selected){
513  row[j]=x0;
514 
515  }
516  break;
517 
518  }
519  case VECTOR_BLOB: {
520  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
521  unsigned int total_size0=H5Tget_size(fieldtype0);
522  hsize_t fieldlen0;
523  H5Tget_array_dims2(fieldtype0, &fieldlen0);
524  hid_t item_type0=H5Tget_super(fieldtype0);
525  unsigned int total_size1elem=H5Tget_size(item_type0);
526  std::vector<cyclus::Blob> x0;
527  x0=std::vector<cyclus::Blob>(fieldlen0);
528  for(unsigned int k0=0;k0<fieldlen0;++k0){
529  cyclus::Blob x1elem;
530  x1elem=VLRead<cyclus::Blob,BLOB>(buf+offset+total_size1elem*k0);
531  x0[k0]=x1elem;
532 
533  }
534  is_row_selected=CmpConds<std::vector<cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
535  if(is_row_selected){
536  row[j]=x0;
537 
538  }
539  H5Tclose(item_type0);
540  H5Tclose(fieldtype0);
541  break;
542 
543  }
544  case VL_VECTOR_BLOB: {
545  unsigned int total_size0=CYCLUS_SHA1_SIZE;
546  std::vector<cyclus::Blob> x0;
547  x0=VLRead<std::vector<cyclus::Blob>,VL_VECTOR_BLOB>(buf+offset);
548  is_row_selected=CmpConds<std::vector<cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
549  if(is_row_selected){
550  row[j]=x0;
551 
552  }
553  break;
554 
555  }
556  case VECTOR_UUID: {
557  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
558  unsigned int total_size0=H5Tget_size(fieldtype0);
559  hsize_t fieldlen0;
560  H5Tget_array_dims2(fieldtype0, &fieldlen0);
561  hid_t item_type0=H5Tget_super(fieldtype0);
562  unsigned int total_size1elem=H5Tget_size(item_type0);
563  std::vector<boost::uuids::uuid> x0;
564  x0=std::vector<boost::uuids::uuid>(fieldlen0);
565  for(unsigned int k0=0;k0<fieldlen0;++k0){
566  boost::uuids::uuid x1elem;
567  memcpy(&x1elem, buf+offset+total_size1elem*k0, total_size1elem);
568  x0[k0]=x1elem;
569 
570  }
571  is_row_selected=CmpConds<std::vector<boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
572  if(is_row_selected){
573  row[j]=x0;
574 
575  }
576  H5Tclose(item_type0);
577  H5Tclose(fieldtype0);
578  break;
579 
580  }
581  case VL_VECTOR_UUID: {
582  unsigned int total_size0=CYCLUS_SHA1_SIZE;
583  std::vector<boost::uuids::uuid> x0;
584  x0=VLRead<std::vector<boost::uuids::uuid>,VL_VECTOR_UUID>(buf+offset);
585  is_row_selected=CmpConds<std::vector<boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
586  if(is_row_selected){
587  row[j]=x0;
588 
589  }
590  break;
591 
592  }
593  case SET_INT: {
594  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
595  unsigned int total_size0=H5Tget_size(fieldtype0);
596  hsize_t fieldlen0;
597  H5Tget_array_dims2(fieldtype0, &fieldlen0);
598  hid_t item_type0=H5Tget_super(fieldtype0);
599  unsigned int total_size1elem=H5Tget_size(item_type0);
600  std::set<int> x0;
601  int* xraw1elem=reinterpret_cast<int*>(buf+offset);
602  x0=std::set<int>(xraw1elem, xraw1elem+fieldlen0);
603  is_row_selected=CmpConds<std::set<int>>(&x0, &(field_conds[qr.fields[j]]));
604  if(is_row_selected){
605  row[j]=x0;
606 
607  }
608  H5Tclose(item_type0);
609  H5Tclose(fieldtype0);
610  break;
611 
612  }
613  case VL_SET_INT: {
614  unsigned int total_size0=CYCLUS_SHA1_SIZE;
615  std::set<int> x0;
616  x0=VLRead<std::set<int>,VL_SET_INT>(buf+offset);
617  is_row_selected=CmpConds<std::set<int>>(&x0, &(field_conds[qr.fields[j]]));
618  if(is_row_selected){
619  row[j]=x0;
620 
621  }
622  break;
623 
624  }
625  case SET_FLOAT: {
626  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
627  unsigned int total_size0=H5Tget_size(fieldtype0);
628  hsize_t fieldlen0;
629  H5Tget_array_dims2(fieldtype0, &fieldlen0);
630  hid_t item_type0=H5Tget_super(fieldtype0);
631  unsigned int total_size1elem=H5Tget_size(item_type0);
632  std::set<float> x0;
633  float* xraw1elem=reinterpret_cast<float*>(buf+offset);
634  x0=std::set<float>(xraw1elem, xraw1elem+fieldlen0);
635  is_row_selected=CmpConds<std::set<float>>(&x0, &(field_conds[qr.fields[j]]));
636  if(is_row_selected){
637  row[j]=x0;
638 
639  }
640  H5Tclose(item_type0);
641  H5Tclose(fieldtype0);
642  break;
643 
644  }
645  case VL_SET_FLOAT: {
646  unsigned int total_size0=CYCLUS_SHA1_SIZE;
647  std::set<float> x0;
648  x0=VLRead<std::set<float>,VL_SET_FLOAT>(buf+offset);
649  is_row_selected=CmpConds<std::set<float>>(&x0, &(field_conds[qr.fields[j]]));
650  if(is_row_selected){
651  row[j]=x0;
652 
653  }
654  break;
655 
656  }
657  case SET_DOUBLE: {
658  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
659  unsigned int total_size0=H5Tget_size(fieldtype0);
660  hsize_t fieldlen0;
661  H5Tget_array_dims2(fieldtype0, &fieldlen0);
662  hid_t item_type0=H5Tget_super(fieldtype0);
663  unsigned int total_size1elem=H5Tget_size(item_type0);
664  std::set<double> x0;
665  double* xraw1elem=reinterpret_cast<double*>(buf+offset);
666  x0=std::set<double>(xraw1elem, xraw1elem+fieldlen0);
667  is_row_selected=CmpConds<std::set<double>>(&x0, &(field_conds[qr.fields[j]]));
668  if(is_row_selected){
669  row[j]=x0;
670 
671  }
672  H5Tclose(item_type0);
673  H5Tclose(fieldtype0);
674  break;
675 
676  }
677  case VL_SET_DOUBLE: {
678  unsigned int total_size0=CYCLUS_SHA1_SIZE;
679  std::set<double> x0;
680  x0=VLRead<std::set<double>,VL_SET_DOUBLE>(buf+offset);
681  is_row_selected=CmpConds<std::set<double>>(&x0, &(field_conds[qr.fields[j]]));
682  if(is_row_selected){
683  row[j]=x0;
684 
685  }
686  break;
687 
688  }
689  case SET_STRING: {
690  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
691  unsigned int total_size0=H5Tget_size(fieldtype0);
692  hsize_t fieldlen0;
693  H5Tget_array_dims2(fieldtype0, &fieldlen0);
694  hid_t item_type0=H5Tget_super(fieldtype0);
695  size_t nullpos1elem;
696  unsigned int total_size1elem=H5Tget_size(item_type0);
697  std::set<std::string> x0;
698  for(unsigned int k0=0;k0<fieldlen0;++k0){
699  std::string x1elem;
700  x1elem=std::string(buf+offset+total_size1elem*k0, total_size1elem);
701  nullpos1elem=x1elem.find('\0');
702  if(nullpos1elem!=std::string::npos){
703  x1elem.resize(nullpos1elem);
704 
705  }
706  x0.insert(x1elem);
707 
708  }
709  is_row_selected=CmpConds<std::set<std::string>>(&x0, &(field_conds[qr.fields[j]]));
710  if(is_row_selected){
711  row[j]=x0;
712 
713  }
714  H5Tclose(item_type0);
715  H5Tclose(fieldtype0);
716  break;
717 
718  }
719  case VL_SET_STRING: {
720  unsigned int total_size0=CYCLUS_SHA1_SIZE;
721  std::set<std::string> x0;
722  x0=VLRead<std::set<std::string>,VL_SET_STRING>(buf+offset);
723  is_row_selected=CmpConds<std::set<std::string>>(&x0, &(field_conds[qr.fields[j]]));
724  if(is_row_selected){
725  row[j]=x0;
726 
727  }
728  break;
729 
730  }
731  case SET_VL_STRING: {
732  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
733  unsigned int total_size0=H5Tget_size(fieldtype0);
734  hsize_t fieldlen0;
735  H5Tget_array_dims2(fieldtype0, &fieldlen0);
736  hid_t item_type0=H5Tget_super(fieldtype0);
737  unsigned int total_size1elem=H5Tget_size(item_type0);
738  std::set<std::string> x0;
739  for(unsigned int k0=0;k0<fieldlen0;++k0){
740  std::string x1elem;
741  x1elem=VLRead<std::string,VL_STRING>(buf+offset+total_size1elem*k0);
742  x0.insert(x1elem);
743 
744  }
745  is_row_selected=CmpConds<std::set<std::string>>(&x0, &(field_conds[qr.fields[j]]));
746  if(is_row_selected){
747  row[j]=x0;
748 
749  }
750  H5Tclose(item_type0);
751  H5Tclose(fieldtype0);
752  break;
753 
754  }
755  case VL_SET_VL_STRING: {
756  unsigned int total_size0=CYCLUS_SHA1_SIZE;
757  std::set<std::string> x0;
758  x0=VLRead<std::set<std::string>,VL_SET_VL_STRING>(buf+offset);
759  is_row_selected=CmpConds<std::set<std::string>>(&x0, &(field_conds[qr.fields[j]]));
760  if(is_row_selected){
761  row[j]=x0;
762 
763  }
764  break;
765 
766  }
767  case SET_BLOB: {
768  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
769  unsigned int total_size0=H5Tget_size(fieldtype0);
770  hsize_t fieldlen0;
771  H5Tget_array_dims2(fieldtype0, &fieldlen0);
772  hid_t item_type0=H5Tget_super(fieldtype0);
773  unsigned int total_size1elem=H5Tget_size(item_type0);
774  std::set<cyclus::Blob> x0;
775  for(unsigned int k0=0;k0<fieldlen0;++k0){
776  cyclus::Blob x1elem;
777  x1elem=VLRead<cyclus::Blob,BLOB>(buf+offset+total_size1elem*k0);
778  x0.insert(x1elem);
779 
780  }
781  is_row_selected=CmpConds<std::set<cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
782  if(is_row_selected){
783  row[j]=x0;
784 
785  }
786  H5Tclose(item_type0);
787  H5Tclose(fieldtype0);
788  break;
789 
790  }
791  case VL_SET_BLOB: {
792  unsigned int total_size0=CYCLUS_SHA1_SIZE;
793  std::set<cyclus::Blob> x0;
794  x0=VLRead<std::set<cyclus::Blob>,VL_SET_BLOB>(buf+offset);
795  is_row_selected=CmpConds<std::set<cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
796  if(is_row_selected){
797  row[j]=x0;
798 
799  }
800  break;
801 
802  }
803  case SET_UUID: {
804  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
805  unsigned int total_size0=H5Tget_size(fieldtype0);
806  hsize_t fieldlen0;
807  H5Tget_array_dims2(fieldtype0, &fieldlen0);
808  hid_t item_type0=H5Tget_super(fieldtype0);
809  unsigned int total_size1elem=H5Tget_size(item_type0);
810  std::set<boost::uuids::uuid> x0;
811  for(unsigned int k0=0;k0<fieldlen0;++k0){
812  boost::uuids::uuid x1elem;
813  memcpy(&x1elem, buf+offset+total_size1elem*k0, total_size1elem);
814  x0.insert(x1elem);
815 
816  }
817  is_row_selected=CmpConds<std::set<boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
818  if(is_row_selected){
819  row[j]=x0;
820 
821  }
822  H5Tclose(item_type0);
823  H5Tclose(fieldtype0);
824  break;
825 
826  }
827  case VL_SET_UUID: {
828  unsigned int total_size0=CYCLUS_SHA1_SIZE;
829  std::set<boost::uuids::uuid> x0;
830  x0=VLRead<std::set<boost::uuids::uuid>,VL_SET_UUID>(buf+offset);
831  is_row_selected=CmpConds<std::set<boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
832  if(is_row_selected){
833  row[j]=x0;
834 
835  }
836  break;
837 
838  }
839  case LIST_BOOL: {
840  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
841  unsigned int total_size0=H5Tget_size(fieldtype0);
842  hsize_t fieldlen0;
843  H5Tget_array_dims2(fieldtype0, &fieldlen0);
844  hid_t item_type0=H5Tget_super(fieldtype0);
845  unsigned int total_size1elem=H5Tget_size(item_type0);
846  std::list<bool> x0;
847  for(unsigned int k0=0;k0<fieldlen0;++k0){
848  bool x1elem;
849  x1elem=*reinterpret_cast<bool*>(buf+offset+total_size1elem*k0);
850  x0.push_back(x1elem);
851 
852  }
853  is_row_selected=CmpConds<std::list<bool>>(&x0, &(field_conds[qr.fields[j]]));
854  if(is_row_selected){
855  row[j]=x0;
856 
857  }
858  H5Tclose(item_type0);
859  H5Tclose(fieldtype0);
860  break;
861 
862  }
863  case VL_LIST_BOOL: {
864  unsigned int total_size0=CYCLUS_SHA1_SIZE;
865  std::list<bool> x0;
866  x0=VLRead<std::list<bool>,VL_LIST_BOOL>(buf+offset);
867  is_row_selected=CmpConds<std::list<bool>>(&x0, &(field_conds[qr.fields[j]]));
868  if(is_row_selected){
869  row[j]=x0;
870 
871  }
872  break;
873 
874  }
875  case LIST_INT: {
876  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
877  unsigned int total_size0=H5Tget_size(fieldtype0);
878  hsize_t fieldlen0;
879  H5Tget_array_dims2(fieldtype0, &fieldlen0);
880  hid_t item_type0=H5Tget_super(fieldtype0);
881  unsigned int total_size1elem=H5Tget_size(item_type0);
882  std::list<int> x0;
883  int* xraw1elem=reinterpret_cast<int*>(buf+offset);
884  x0=std::list<int>(xraw1elem, xraw1elem+fieldlen0);
885  is_row_selected=CmpConds<std::list<int>>(&x0, &(field_conds[qr.fields[j]]));
886  if(is_row_selected){
887  row[j]=x0;
888 
889  }
890  H5Tclose(item_type0);
891  H5Tclose(fieldtype0);
892  break;
893 
894  }
895  case VL_LIST_INT: {
896  unsigned int total_size0=CYCLUS_SHA1_SIZE;
897  std::list<int> x0;
898  x0=VLRead<std::list<int>,VL_LIST_INT>(buf+offset);
899  is_row_selected=CmpConds<std::list<int>>(&x0, &(field_conds[qr.fields[j]]));
900  if(is_row_selected){
901  row[j]=x0;
902 
903  }
904  break;
905 
906  }
907  case LIST_FLOAT: {
908  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
909  unsigned int total_size0=H5Tget_size(fieldtype0);
910  hsize_t fieldlen0;
911  H5Tget_array_dims2(fieldtype0, &fieldlen0);
912  hid_t item_type0=H5Tget_super(fieldtype0);
913  unsigned int total_size1elem=H5Tget_size(item_type0);
914  std::list<float> x0;
915  float* xraw1elem=reinterpret_cast<float*>(buf+offset);
916  x0=std::list<float>(xraw1elem, xraw1elem+fieldlen0);
917  is_row_selected=CmpConds<std::list<float>>(&x0, &(field_conds[qr.fields[j]]));
918  if(is_row_selected){
919  row[j]=x0;
920 
921  }
922  H5Tclose(item_type0);
923  H5Tclose(fieldtype0);
924  break;
925 
926  }
927  case VL_LIST_FLOAT: {
928  unsigned int total_size0=CYCLUS_SHA1_SIZE;
929  std::list<float> x0;
930  x0=VLRead<std::list<float>,VL_LIST_FLOAT>(buf+offset);
931  is_row_selected=CmpConds<std::list<float>>(&x0, &(field_conds[qr.fields[j]]));
932  if(is_row_selected){
933  row[j]=x0;
934 
935  }
936  break;
937 
938  }
939  case LIST_DOUBLE: {
940  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
941  unsigned int total_size0=H5Tget_size(fieldtype0);
942  hsize_t fieldlen0;
943  H5Tget_array_dims2(fieldtype0, &fieldlen0);
944  hid_t item_type0=H5Tget_super(fieldtype0);
945  unsigned int total_size1elem=H5Tget_size(item_type0);
946  std::list<double> x0;
947  double* xraw1elem=reinterpret_cast<double*>(buf+offset);
948  x0=std::list<double>(xraw1elem, xraw1elem+fieldlen0);
949  is_row_selected=CmpConds<std::list<double>>(&x0, &(field_conds[qr.fields[j]]));
950  if(is_row_selected){
951  row[j]=x0;
952 
953  }
954  H5Tclose(item_type0);
955  H5Tclose(fieldtype0);
956  break;
957 
958  }
959  case VL_LIST_DOUBLE: {
960  unsigned int total_size0=CYCLUS_SHA1_SIZE;
961  std::list<double> x0;
962  x0=VLRead<std::list<double>,VL_LIST_DOUBLE>(buf+offset);
963  is_row_selected=CmpConds<std::list<double>>(&x0, &(field_conds[qr.fields[j]]));
964  if(is_row_selected){
965  row[j]=x0;
966 
967  }
968  break;
969 
970  }
971  case LIST_STRING: {
972  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
973  unsigned int total_size0=H5Tget_size(fieldtype0);
974  hsize_t fieldlen0;
975  H5Tget_array_dims2(fieldtype0, &fieldlen0);
976  hid_t item_type0=H5Tget_super(fieldtype0);
977  size_t nullpos1elem;
978  unsigned int total_size1elem=H5Tget_size(item_type0);
979  std::list<std::string> x0;
980  for(unsigned int k0=0;k0<fieldlen0;++k0){
981  std::string x1elem;
982  x1elem=std::string(buf+offset+total_size1elem*k0, total_size1elem);
983  nullpos1elem=x1elem.find('\0');
984  if(nullpos1elem!=std::string::npos){
985  x1elem.resize(nullpos1elem);
986 
987  }
988  x0.push_back(x1elem);
989 
990  }
991  is_row_selected=CmpConds<std::list<std::string>>(&x0, &(field_conds[qr.fields[j]]));
992  if(is_row_selected){
993  row[j]=x0;
994 
995  }
996  H5Tclose(item_type0);
997  H5Tclose(fieldtype0);
998  break;
999 
1000  }
1001  case VL_LIST_STRING: {
1002  unsigned int total_size0=CYCLUS_SHA1_SIZE;
1003  std::list<std::string> x0;
1004  x0=VLRead<std::list<std::string>,VL_LIST_STRING>(buf+offset);
1005  is_row_selected=CmpConds<std::list<std::string>>(&x0, &(field_conds[qr.fields[j]]));
1006  if(is_row_selected){
1007  row[j]=x0;
1008 
1009  }
1010  break;
1011 
1012  }
1013  case LIST_VL_STRING: {
1014  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1015  unsigned int total_size0=H5Tget_size(fieldtype0);
1016  hsize_t fieldlen0;
1017  H5Tget_array_dims2(fieldtype0, &fieldlen0);
1018  hid_t item_type0=H5Tget_super(fieldtype0);
1019  unsigned int total_size1elem=H5Tget_size(item_type0);
1020  std::list<std::string> x0;
1021  for(unsigned int k0=0;k0<fieldlen0;++k0){
1022  std::string x1elem;
1023  x1elem=VLRead<std::string,VL_STRING>(buf+offset+total_size1elem*k0);
1024  x0.push_back(x1elem);
1025 
1026  }
1027  is_row_selected=CmpConds<std::list<std::string>>(&x0, &(field_conds[qr.fields[j]]));
1028  if(is_row_selected){
1029  row[j]=x0;
1030 
1031  }
1032  H5Tclose(item_type0);
1033  H5Tclose(fieldtype0);
1034  break;
1035 
1036  }
1037  case VL_LIST_VL_STRING: {
1038  unsigned int total_size0=CYCLUS_SHA1_SIZE;
1039  std::list<std::string> x0;
1040  x0=VLRead<std::list<std::string>,VL_LIST_VL_STRING>(buf+offset);
1041  is_row_selected=CmpConds<std::list<std::string>>(&x0, &(field_conds[qr.fields[j]]));
1042  if(is_row_selected){
1043  row[j]=x0;
1044 
1045  }
1046  break;
1047 
1048  }
1049  case LIST_BLOB: {
1050  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1051  unsigned int total_size0=H5Tget_size(fieldtype0);
1052  hsize_t fieldlen0;
1053  H5Tget_array_dims2(fieldtype0, &fieldlen0);
1054  hid_t item_type0=H5Tget_super(fieldtype0);
1055  unsigned int total_size1elem=H5Tget_size(item_type0);
1056  std::list<cyclus::Blob> x0;
1057  for(unsigned int k0=0;k0<fieldlen0;++k0){
1058  cyclus::Blob x1elem;
1059  x1elem=VLRead<cyclus::Blob,BLOB>(buf+offset+total_size1elem*k0);
1060  x0.push_back(x1elem);
1061 
1062  }
1063  is_row_selected=CmpConds<std::list<cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
1064  if(is_row_selected){
1065  row[j]=x0;
1066 
1067  }
1068  H5Tclose(item_type0);
1069  H5Tclose(fieldtype0);
1070  break;
1071 
1072  }
1073  case VL_LIST_BLOB: {
1074  unsigned int total_size0=CYCLUS_SHA1_SIZE;
1075  std::list<cyclus::Blob> x0;
1076  x0=VLRead<std::list<cyclus::Blob>,VL_LIST_BLOB>(buf+offset);
1077  is_row_selected=CmpConds<std::list<cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
1078  if(is_row_selected){
1079  row[j]=x0;
1080 
1081  }
1082  break;
1083 
1084  }
1085  case LIST_UUID: {
1086  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1087  unsigned int total_size0=H5Tget_size(fieldtype0);
1088  hsize_t fieldlen0;
1089  H5Tget_array_dims2(fieldtype0, &fieldlen0);
1090  hid_t item_type0=H5Tget_super(fieldtype0);
1091  unsigned int total_size1elem=H5Tget_size(item_type0);
1092  std::list<boost::uuids::uuid> x0;
1093  for(unsigned int k0=0;k0<fieldlen0;++k0){
1094  boost::uuids::uuid x1elem;
1095  memcpy(&x1elem, buf+offset+total_size1elem*k0, total_size1elem);
1096  x0.push_back(x1elem);
1097 
1098  }
1099  is_row_selected=CmpConds<std::list<boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
1100  if(is_row_selected){
1101  row[j]=x0;
1102 
1103  }
1104  H5Tclose(item_type0);
1105  H5Tclose(fieldtype0);
1106  break;
1107 
1108  }
1109  case VL_LIST_UUID: {
1110  unsigned int total_size0=CYCLUS_SHA1_SIZE;
1111  std::list<boost::uuids::uuid> x0;
1112  x0=VLRead<std::list<boost::uuids::uuid>,VL_LIST_UUID>(buf+offset);
1113  is_row_selected=CmpConds<std::list<boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
1114  if(is_row_selected){
1115  row[j]=x0;
1116 
1117  }
1118  break;
1119 
1120  }
1121  case PAIR_INT_BOOL: {
1122  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1123  unsigned int total_size0=H5Tget_size(fieldtype0);
1124  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1125  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1126  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1127  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1128  std::pair<int, bool> x0;
1129  int x1first;
1130  x1first=*reinterpret_cast<int*>(buf+offset);
1131  bool x1second;
1132  x1second=*reinterpret_cast<bool*>(buf+offset+total_size1first);
1133  x0=std::make_pair(x1first, x1second);
1134  is_row_selected=CmpConds<std::pair<int, bool>>(&x0, &(field_conds[qr.fields[j]]));
1135  if(is_row_selected){
1136  row[j]=x0;
1137 
1138  }
1139  H5Tclose(fieldtype1second);
1140  H5Tclose(fieldtype1first);
1141  H5Tclose(fieldtype0);
1142  break;
1143 
1144  }
1145  case PAIR_INT_INT: {
1146  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1147  unsigned int total_size0=H5Tget_size(fieldtype0);
1148  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1149  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1150  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1151  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1152  std::pair<int, int> x0;
1153  int x1first;
1154  x1first=*reinterpret_cast<int*>(buf+offset);
1155  int x1second;
1156  x1second=*reinterpret_cast<int*>(buf+offset+total_size1first);
1157  x0=std::make_pair(x1first, x1second);
1158  is_row_selected=CmpConds<std::pair<int, int>>(&x0, &(field_conds[qr.fields[j]]));
1159  if(is_row_selected){
1160  row[j]=x0;
1161 
1162  }
1163  H5Tclose(fieldtype1second);
1164  H5Tclose(fieldtype1first);
1165  H5Tclose(fieldtype0);
1166  break;
1167 
1168  }
1169  case PAIR_INT_FLOAT: {
1170  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1171  unsigned int total_size0=H5Tget_size(fieldtype0);
1172  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1173  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1174  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1175  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1176  std::pair<int, float> x0;
1177  int x1first;
1178  x1first=*reinterpret_cast<int*>(buf+offset);
1179  float x1second;
1180  x1second=*reinterpret_cast<float*>(buf+offset+total_size1first);
1181  x0=std::make_pair(x1first, x1second);
1182  is_row_selected=CmpConds<std::pair<int, float>>(&x0, &(field_conds[qr.fields[j]]));
1183  if(is_row_selected){
1184  row[j]=x0;
1185 
1186  }
1187  H5Tclose(fieldtype1second);
1188  H5Tclose(fieldtype1first);
1189  H5Tclose(fieldtype0);
1190  break;
1191 
1192  }
1193  case PAIR_INT_DOUBLE: {
1194  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1195  unsigned int total_size0=H5Tget_size(fieldtype0);
1196  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1197  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1198  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1199  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1200  std::pair<int, double> x0;
1201  int x1first;
1202  x1first=*reinterpret_cast<int*>(buf+offset);
1203  double x1second;
1204  x1second=*reinterpret_cast<double*>(buf+offset+total_size1first);
1205  x0=std::make_pair(x1first, x1second);
1206  is_row_selected=CmpConds<std::pair<int, double>>(&x0, &(field_conds[qr.fields[j]]));
1207  if(is_row_selected){
1208  row[j]=x0;
1209 
1210  }
1211  H5Tclose(fieldtype1second);
1212  H5Tclose(fieldtype1first);
1213  H5Tclose(fieldtype0);
1214  break;
1215 
1216  }
1217  case PAIR_INT_STRING: {
1218  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1219  unsigned int total_size0=H5Tget_size(fieldtype0);
1220  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1221  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1222  size_t nullpos1second;
1223  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1224  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1225  std::pair<int, std::string> x0;
1226  int x1first;
1227  x1first=*reinterpret_cast<int*>(buf+offset);
1228  std::string x1second;
1229  x1second=std::string(buf+offset+total_size1first, total_size1second);
1230  nullpos1second=x1second.find('\0');
1231  if(nullpos1second!=std::string::npos){
1232  x1second.resize(nullpos1second);
1233 
1234  }
1235  x0=std::make_pair(x1first, x1second);
1236  is_row_selected=CmpConds<std::pair<int, std::string>>(&x0, &(field_conds[qr.fields[j]]));
1237  if(is_row_selected){
1238  row[j]=x0;
1239 
1240  }
1241  H5Tclose(fieldtype1second);
1242  H5Tclose(fieldtype1first);
1243  H5Tclose(fieldtype0);
1244  break;
1245 
1246  }
1247  case PAIR_INT_VL_STRING: {
1248  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1249  unsigned int total_size0=H5Tget_size(fieldtype0);
1250  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1251  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1252  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1253  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1254  std::pair<int, std::string> x0;
1255  int x1first;
1256  x1first=*reinterpret_cast<int*>(buf+offset);
1257  std::string x1second;
1258  x1second=VLRead<std::string,VL_STRING>(buf+offset+total_size1first);
1259  x0=std::make_pair(x1first, x1second);
1260  is_row_selected=CmpConds<std::pair<int, std::string>>(&x0, &(field_conds[qr.fields[j]]));
1261  if(is_row_selected){
1262  row[j]=x0;
1263 
1264  }
1265  H5Tclose(fieldtype1second);
1266  H5Tclose(fieldtype1first);
1267  H5Tclose(fieldtype0);
1268  break;
1269 
1270  }
1271  case PAIR_INT_BLOB: {
1272  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1273  unsigned int total_size0=H5Tget_size(fieldtype0);
1274  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1275  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1276  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1277  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1278  std::pair<int, cyclus::Blob> x0;
1279  int x1first;
1280  x1first=*reinterpret_cast<int*>(buf+offset);
1281  cyclus::Blob x1second;
1282  x1second=VLRead<cyclus::Blob,BLOB>(buf+offset+total_size1first);
1283  x0=std::make_pair(x1first, x1second);
1284  is_row_selected=CmpConds<std::pair<int, cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
1285  if(is_row_selected){
1286  row[j]=x0;
1287 
1288  }
1289  H5Tclose(fieldtype1second);
1290  H5Tclose(fieldtype1first);
1291  H5Tclose(fieldtype0);
1292  break;
1293 
1294  }
1295  case PAIR_INT_UUID: {
1296  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1297  unsigned int total_size0=H5Tget_size(fieldtype0);
1298  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1299  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1300  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1301  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1302  std::pair<int, boost::uuids::uuid> x0;
1303  int x1first;
1304  x1first=*reinterpret_cast<int*>(buf+offset);
1305  boost::uuids::uuid x1second;
1306  memcpy(&x1second, buf+offset+total_size1first, total_size1second);
1307  x0=std::make_pair(x1first, x1second);
1308  is_row_selected=CmpConds<std::pair<int, boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
1309  if(is_row_selected){
1310  row[j]=x0;
1311 
1312  }
1313  H5Tclose(fieldtype1second);
1314  H5Tclose(fieldtype1first);
1315  H5Tclose(fieldtype0);
1316  break;
1317 
1318  }
1319  case PAIR_STRING_BOOL: {
1320  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1321  unsigned int total_size0=H5Tget_size(fieldtype0);
1322  size_t nullpos1first;
1323  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1324  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1325  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1326  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1327  std::pair<std::string, bool> x0;
1328  std::string x1first;
1329  x1first=std::string(buf+offset, total_size1first);
1330  nullpos1first=x1first.find('\0');
1331  if(nullpos1first!=std::string::npos){
1332  x1first.resize(nullpos1first);
1333 
1334  }
1335  bool x1second;
1336  x1second=*reinterpret_cast<bool*>(buf+offset+total_size1first);
1337  x0=std::make_pair(x1first, x1second);
1338  is_row_selected=CmpConds<std::pair<std::string, bool>>(&x0, &(field_conds[qr.fields[j]]));
1339  if(is_row_selected){
1340  row[j]=x0;
1341 
1342  }
1343  H5Tclose(fieldtype1second);
1344  H5Tclose(fieldtype1first);
1345  H5Tclose(fieldtype0);
1346  break;
1347 
1348  }
1349  case PAIR_STRING_INT: {
1350  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1351  unsigned int total_size0=H5Tget_size(fieldtype0);
1352  size_t nullpos1first;
1353  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1354  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1355  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1356  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1357  std::pair<std::string, int> x0;
1358  std::string x1first;
1359  x1first=std::string(buf+offset, total_size1first);
1360  nullpos1first=x1first.find('\0');
1361  if(nullpos1first!=std::string::npos){
1362  x1first.resize(nullpos1first);
1363 
1364  }
1365  int x1second;
1366  x1second=*reinterpret_cast<int*>(buf+offset+total_size1first);
1367  x0=std::make_pair(x1first, x1second);
1368  is_row_selected=CmpConds<std::pair<std::string, int>>(&x0, &(field_conds[qr.fields[j]]));
1369  if(is_row_selected){
1370  row[j]=x0;
1371 
1372  }
1373  H5Tclose(fieldtype1second);
1374  H5Tclose(fieldtype1first);
1375  H5Tclose(fieldtype0);
1376  break;
1377 
1378  }
1379  case PAIR_STRING_FLOAT: {
1380  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1381  unsigned int total_size0=H5Tget_size(fieldtype0);
1382  size_t nullpos1first;
1383  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1384  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1385  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1386  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1387  std::pair<std::string, float> x0;
1388  std::string x1first;
1389  x1first=std::string(buf+offset, total_size1first);
1390  nullpos1first=x1first.find('\0');
1391  if(nullpos1first!=std::string::npos){
1392  x1first.resize(nullpos1first);
1393 
1394  }
1395  float x1second;
1396  x1second=*reinterpret_cast<float*>(buf+offset+total_size1first);
1397  x0=std::make_pair(x1first, x1second);
1398  is_row_selected=CmpConds<std::pair<std::string, float>>(&x0, &(field_conds[qr.fields[j]]));
1399  if(is_row_selected){
1400  row[j]=x0;
1401 
1402  }
1403  H5Tclose(fieldtype1second);
1404  H5Tclose(fieldtype1first);
1405  H5Tclose(fieldtype0);
1406  break;
1407 
1408  }
1409  case PAIR_STRING_DOUBLE: {
1410  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1411  unsigned int total_size0=H5Tget_size(fieldtype0);
1412  size_t nullpos1first;
1413  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1414  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1415  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1416  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1417  std::pair<std::string, double> x0;
1418  std::string x1first;
1419  x1first=std::string(buf+offset, total_size1first);
1420  nullpos1first=x1first.find('\0');
1421  if(nullpos1first!=std::string::npos){
1422  x1first.resize(nullpos1first);
1423 
1424  }
1425  double x1second;
1426  x1second=*reinterpret_cast<double*>(buf+offset+total_size1first);
1427  x0=std::make_pair(x1first, x1second);
1428  is_row_selected=CmpConds<std::pair<std::string, double>>(&x0, &(field_conds[qr.fields[j]]));
1429  if(is_row_selected){
1430  row[j]=x0;
1431 
1432  }
1433  H5Tclose(fieldtype1second);
1434  H5Tclose(fieldtype1first);
1435  H5Tclose(fieldtype0);
1436  break;
1437 
1438  }
1439  case PAIR_STRING_STRING: {
1440  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1441  unsigned int total_size0=H5Tget_size(fieldtype0);
1442  size_t nullpos1first;
1443  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1444  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1445  size_t nullpos1second;
1446  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1447  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1448  std::pair<std::string, std::string> x0;
1449  std::string x1first;
1450  x1first=std::string(buf+offset, total_size1first);
1451  nullpos1first=x1first.find('\0');
1452  if(nullpos1first!=std::string::npos){
1453  x1first.resize(nullpos1first);
1454 
1455  }
1456  std::string x1second;
1457  x1second=std::string(buf+offset+total_size1first, total_size1second);
1458  nullpos1second=x1second.find('\0');
1459  if(nullpos1second!=std::string::npos){
1460  x1second.resize(nullpos1second);
1461 
1462  }
1463  x0=std::make_pair(x1first, x1second);
1464  is_row_selected=CmpConds<std::pair<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
1465  if(is_row_selected){
1466  row[j]=x0;
1467 
1468  }
1469  H5Tclose(fieldtype1second);
1470  H5Tclose(fieldtype1first);
1471  H5Tclose(fieldtype0);
1472  break;
1473 
1474  }
1475  case PAIR_STRING_VL_STRING: {
1476  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1477  unsigned int total_size0=H5Tget_size(fieldtype0);
1478  size_t nullpos1first;
1479  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1480  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1481  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1482  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1483  std::pair<std::string, std::string> x0;
1484  std::string x1first;
1485  x1first=std::string(buf+offset, total_size1first);
1486  nullpos1first=x1first.find('\0');
1487  if(nullpos1first!=std::string::npos){
1488  x1first.resize(nullpos1first);
1489 
1490  }
1491  std::string x1second;
1492  x1second=VLRead<std::string,VL_STRING>(buf+offset+total_size1first);
1493  x0=std::make_pair(x1first, x1second);
1494  is_row_selected=CmpConds<std::pair<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
1495  if(is_row_selected){
1496  row[j]=x0;
1497 
1498  }
1499  H5Tclose(fieldtype1second);
1500  H5Tclose(fieldtype1first);
1501  H5Tclose(fieldtype0);
1502  break;
1503 
1504  }
1505  case PAIR_STRING_BLOB: {
1506  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1507  unsigned int total_size0=H5Tget_size(fieldtype0);
1508  size_t nullpos1first;
1509  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1510  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1511  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1512  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1513  std::pair<std::string, cyclus::Blob> x0;
1514  std::string x1first;
1515  x1first=std::string(buf+offset, total_size1first);
1516  nullpos1first=x1first.find('\0');
1517  if(nullpos1first!=std::string::npos){
1518  x1first.resize(nullpos1first);
1519 
1520  }
1521  cyclus::Blob x1second;
1522  x1second=VLRead<cyclus::Blob,BLOB>(buf+offset+total_size1first);
1523  x0=std::make_pair(x1first, x1second);
1524  is_row_selected=CmpConds<std::pair<std::string, cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
1525  if(is_row_selected){
1526  row[j]=x0;
1527 
1528  }
1529  H5Tclose(fieldtype1second);
1530  H5Tclose(fieldtype1first);
1531  H5Tclose(fieldtype0);
1532  break;
1533 
1534  }
1535  case PAIR_STRING_UUID: {
1536  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1537  unsigned int total_size0=H5Tget_size(fieldtype0);
1538  size_t nullpos1first;
1539  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1540  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1541  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1542  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1543  std::pair<std::string, boost::uuids::uuid> x0;
1544  std::string x1first;
1545  x1first=std::string(buf+offset, total_size1first);
1546  nullpos1first=x1first.find('\0');
1547  if(nullpos1first!=std::string::npos){
1548  x1first.resize(nullpos1first);
1549 
1550  }
1551  boost::uuids::uuid x1second;
1552  memcpy(&x1second, buf+offset+total_size1first, total_size1second);
1553  x0=std::make_pair(x1first, x1second);
1554  is_row_selected=CmpConds<std::pair<std::string, boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
1555  if(is_row_selected){
1556  row[j]=x0;
1557 
1558  }
1559  H5Tclose(fieldtype1second);
1560  H5Tclose(fieldtype1first);
1561  H5Tclose(fieldtype0);
1562  break;
1563 
1564  }
1565  case PAIR_VL_STRING_BOOL: {
1566  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1567  unsigned int total_size0=H5Tget_size(fieldtype0);
1568  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1569  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1570  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1571  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1572  std::pair<std::string, bool> x0;
1573  std::string x1first;
1574  x1first=VLRead<std::string,VL_STRING>(buf+offset);
1575  bool x1second;
1576  x1second=*reinterpret_cast<bool*>(buf+offset+total_size1first);
1577  x0=std::make_pair(x1first, x1second);
1578  is_row_selected=CmpConds<std::pair<std::string, bool>>(&x0, &(field_conds[qr.fields[j]]));
1579  if(is_row_selected){
1580  row[j]=x0;
1581 
1582  }
1583  H5Tclose(fieldtype1second);
1584  H5Tclose(fieldtype1first);
1585  H5Tclose(fieldtype0);
1586  break;
1587 
1588  }
1589  case PAIR_VL_STRING_INT: {
1590  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1591  unsigned int total_size0=H5Tget_size(fieldtype0);
1592  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1593  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1594  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1595  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1596  std::pair<std::string, int> x0;
1597  std::string x1first;
1598  x1first=VLRead<std::string,VL_STRING>(buf+offset);
1599  int x1second;
1600  x1second=*reinterpret_cast<int*>(buf+offset+total_size1first);
1601  x0=std::make_pair(x1first, x1second);
1602  is_row_selected=CmpConds<std::pair<std::string, int>>(&x0, &(field_conds[qr.fields[j]]));
1603  if(is_row_selected){
1604  row[j]=x0;
1605 
1606  }
1607  H5Tclose(fieldtype1second);
1608  H5Tclose(fieldtype1first);
1609  H5Tclose(fieldtype0);
1610  break;
1611 
1612  }
1613  case PAIR_VL_STRING_FLOAT: {
1614  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1615  unsigned int total_size0=H5Tget_size(fieldtype0);
1616  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1617  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1618  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1619  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1620  std::pair<std::string, float> x0;
1621  std::string x1first;
1622  x1first=VLRead<std::string,VL_STRING>(buf+offset);
1623  float x1second;
1624  x1second=*reinterpret_cast<float*>(buf+offset+total_size1first);
1625  x0=std::make_pair(x1first, x1second);
1626  is_row_selected=CmpConds<std::pair<std::string, float>>(&x0, &(field_conds[qr.fields[j]]));
1627  if(is_row_selected){
1628  row[j]=x0;
1629 
1630  }
1631  H5Tclose(fieldtype1second);
1632  H5Tclose(fieldtype1first);
1633  H5Tclose(fieldtype0);
1634  break;
1635 
1636  }
1637  case PAIR_VL_STRING_DOUBLE: {
1638  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1639  unsigned int total_size0=H5Tget_size(fieldtype0);
1640  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1641  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1642  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1643  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1644  std::pair<std::string, double> x0;
1645  std::string x1first;
1646  x1first=VLRead<std::string,VL_STRING>(buf+offset);
1647  double x1second;
1648  x1second=*reinterpret_cast<double*>(buf+offset+total_size1first);
1649  x0=std::make_pair(x1first, x1second);
1650  is_row_selected=CmpConds<std::pair<std::string, double>>(&x0, &(field_conds[qr.fields[j]]));
1651  if(is_row_selected){
1652  row[j]=x0;
1653 
1654  }
1655  H5Tclose(fieldtype1second);
1656  H5Tclose(fieldtype1first);
1657  H5Tclose(fieldtype0);
1658  break;
1659 
1660  }
1661  case PAIR_VL_STRING_STRING: {
1662  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1663  unsigned int total_size0=H5Tget_size(fieldtype0);
1664  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1665  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1666  size_t nullpos1second;
1667  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1668  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1669  std::pair<std::string, std::string> x0;
1670  std::string x1first;
1671  x1first=VLRead<std::string,VL_STRING>(buf+offset);
1672  std::string x1second;
1673  x1second=std::string(buf+offset+total_size1first, total_size1second);
1674  nullpos1second=x1second.find('\0');
1675  if(nullpos1second!=std::string::npos){
1676  x1second.resize(nullpos1second);
1677 
1678  }
1679  x0=std::make_pair(x1first, x1second);
1680  is_row_selected=CmpConds<std::pair<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
1681  if(is_row_selected){
1682  row[j]=x0;
1683 
1684  }
1685  H5Tclose(fieldtype1second);
1686  H5Tclose(fieldtype1first);
1687  H5Tclose(fieldtype0);
1688  break;
1689 
1690  }
1691  case PAIR_VL_STRING_VL_STRING: {
1692  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1693  unsigned int total_size0=H5Tget_size(fieldtype0);
1694  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1695  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1696  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1697  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1698  std::pair<std::string, std::string> x0;
1699  std::string x1first;
1700  x1first=VLRead<std::string,VL_STRING>(buf+offset);
1701  std::string x1second;
1702  x1second=VLRead<std::string,VL_STRING>(buf+offset+total_size1first);
1703  x0=std::make_pair(x1first, x1second);
1704  is_row_selected=CmpConds<std::pair<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
1705  if(is_row_selected){
1706  row[j]=x0;
1707 
1708  }
1709  H5Tclose(fieldtype1second);
1710  H5Tclose(fieldtype1first);
1711  H5Tclose(fieldtype0);
1712  break;
1713 
1714  }
1715  case PAIR_VL_STRING_BLOB: {
1716  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1717  unsigned int total_size0=H5Tget_size(fieldtype0);
1718  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1719  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1720  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1721  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1722  std::pair<std::string, cyclus::Blob> x0;
1723  std::string x1first;
1724  x1first=VLRead<std::string,VL_STRING>(buf+offset);
1725  cyclus::Blob x1second;
1726  x1second=VLRead<cyclus::Blob,BLOB>(buf+offset+total_size1first);
1727  x0=std::make_pair(x1first, x1second);
1728  is_row_selected=CmpConds<std::pair<std::string, cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
1729  if(is_row_selected){
1730  row[j]=x0;
1731 
1732  }
1733  H5Tclose(fieldtype1second);
1734  H5Tclose(fieldtype1first);
1735  H5Tclose(fieldtype0);
1736  break;
1737 
1738  }
1739  case PAIR_VL_STRING_UUID: {
1740  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1741  unsigned int total_size0=H5Tget_size(fieldtype0);
1742  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
1743  unsigned int total_size1first=H5Tget_size(fieldtype1first);
1744  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
1745  unsigned int total_size1second=H5Tget_size(fieldtype1second);
1746  std::pair<std::string, boost::uuids::uuid> x0;
1747  std::string x1first;
1748  x1first=VLRead<std::string,VL_STRING>(buf+offset);
1749  boost::uuids::uuid x1second;
1750  memcpy(&x1second, buf+offset+total_size1first, total_size1second);
1751  x0=std::make_pair(x1first, x1second);
1752  is_row_selected=CmpConds<std::pair<std::string, boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
1753  if(is_row_selected){
1754  row[j]=x0;
1755 
1756  }
1757  H5Tclose(fieldtype1second);
1758  H5Tclose(fieldtype1first);
1759  H5Tclose(fieldtype0);
1760  break;
1761 
1762  }
1763  case MAP_INT_BOOL: {
1764  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1765  unsigned int total_size0=H5Tget_size(fieldtype0);
1766  hsize_t fieldlen0;
1767  H5Tget_array_dims2(fieldtype0, &fieldlen0);
1768  hid_t item_type0=H5Tget_super(fieldtype0);
1769  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
1770  unsigned int total_size1key=H5Tget_size(fieldtype1key);
1771  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
1772  unsigned int total_size1val=H5Tget_size(fieldtype1val);
1773  std::map<int, bool> x0;
1774  for(unsigned int k0=0;k0<fieldlen0;++k0){
1775  int x1key;
1776  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
1777  bool x1val;
1778  x1val=*reinterpret_cast<bool*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
1779  x0[x1key]=x1val;
1780 
1781  }
1782  is_row_selected=CmpConds<std::map<int, bool>>(&x0, &(field_conds[qr.fields[j]]));
1783  if(is_row_selected){
1784  row[j]=x0;
1785 
1786  }
1787  H5Tclose(fieldtype1val);
1788  H5Tclose(fieldtype1key);
1789  H5Tclose(item_type0);
1790  H5Tclose(fieldtype0);
1791  break;
1792 
1793  }
1794  case VL_MAP_INT_BOOL: {
1795  unsigned int total_size0=CYCLUS_SHA1_SIZE;
1796  std::map<int, bool> x0;
1797  x0=VLRead<std::map<int, bool>,VL_MAP_INT_BOOL>(buf+offset);
1798  is_row_selected=CmpConds<std::map<int, bool>>(&x0, &(field_conds[qr.fields[j]]));
1799  if(is_row_selected){
1800  row[j]=x0;
1801 
1802  }
1803  break;
1804 
1805  }
1806  case MAP_INT_INT: {
1807  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1808  unsigned int total_size0=H5Tget_size(fieldtype0);
1809  hsize_t fieldlen0;
1810  H5Tget_array_dims2(fieldtype0, &fieldlen0);
1811  hid_t item_type0=H5Tget_super(fieldtype0);
1812  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
1813  unsigned int total_size1key=H5Tget_size(fieldtype1key);
1814  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
1815  unsigned int total_size1val=H5Tget_size(fieldtype1val);
1816  std::map<int, int> x0;
1817  for(unsigned int k0=0;k0<fieldlen0;++k0){
1818  int x1key;
1819  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
1820  int x1val;
1821  x1val=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
1822  x0[x1key]=x1val;
1823 
1824  }
1825  is_row_selected=CmpConds<std::map<int, int>>(&x0, &(field_conds[qr.fields[j]]));
1826  if(is_row_selected){
1827  row[j]=x0;
1828 
1829  }
1830  H5Tclose(fieldtype1val);
1831  H5Tclose(fieldtype1key);
1832  H5Tclose(item_type0);
1833  H5Tclose(fieldtype0);
1834  break;
1835 
1836  }
1837  case VL_MAP_INT_INT: {
1838  unsigned int total_size0=CYCLUS_SHA1_SIZE;
1839  std::map<int, int> x0;
1840  x0=VLRead<std::map<int, int>,VL_MAP_INT_INT>(buf+offset);
1841  is_row_selected=CmpConds<std::map<int, int>>(&x0, &(field_conds[qr.fields[j]]));
1842  if(is_row_selected){
1843  row[j]=x0;
1844 
1845  }
1846  break;
1847 
1848  }
1849  case MAP_INT_FLOAT: {
1850  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1851  unsigned int total_size0=H5Tget_size(fieldtype0);
1852  hsize_t fieldlen0;
1853  H5Tget_array_dims2(fieldtype0, &fieldlen0);
1854  hid_t item_type0=H5Tget_super(fieldtype0);
1855  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
1856  unsigned int total_size1key=H5Tget_size(fieldtype1key);
1857  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
1858  unsigned int total_size1val=H5Tget_size(fieldtype1val);
1859  std::map<int, float> x0;
1860  for(unsigned int k0=0;k0<fieldlen0;++k0){
1861  int x1key;
1862  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
1863  float x1val;
1864  x1val=*reinterpret_cast<float*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
1865  x0[x1key]=x1val;
1866 
1867  }
1868  is_row_selected=CmpConds<std::map<int, float>>(&x0, &(field_conds[qr.fields[j]]));
1869  if(is_row_selected){
1870  row[j]=x0;
1871 
1872  }
1873  H5Tclose(fieldtype1val);
1874  H5Tclose(fieldtype1key);
1875  H5Tclose(item_type0);
1876  H5Tclose(fieldtype0);
1877  break;
1878 
1879  }
1880  case VL_MAP_INT_FLOAT: {
1881  unsigned int total_size0=CYCLUS_SHA1_SIZE;
1882  std::map<int, float> x0;
1883  x0=VLRead<std::map<int, float>,VL_MAP_INT_FLOAT>(buf+offset);
1884  is_row_selected=CmpConds<std::map<int, float>>(&x0, &(field_conds[qr.fields[j]]));
1885  if(is_row_selected){
1886  row[j]=x0;
1887 
1888  }
1889  break;
1890 
1891  }
1892  case MAP_INT_DOUBLE: {
1893  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1894  unsigned int total_size0=H5Tget_size(fieldtype0);
1895  hsize_t fieldlen0;
1896  H5Tget_array_dims2(fieldtype0, &fieldlen0);
1897  hid_t item_type0=H5Tget_super(fieldtype0);
1898  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
1899  unsigned int total_size1key=H5Tget_size(fieldtype1key);
1900  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
1901  unsigned int total_size1val=H5Tget_size(fieldtype1val);
1902  std::map<int, double> x0;
1903  for(unsigned int k0=0;k0<fieldlen0;++k0){
1904  int x1key;
1905  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
1906  double x1val;
1907  x1val=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
1908  x0[x1key]=x1val;
1909 
1910  }
1911  is_row_selected=CmpConds<std::map<int, double>>(&x0, &(field_conds[qr.fields[j]]));
1912  if(is_row_selected){
1913  row[j]=x0;
1914 
1915  }
1916  H5Tclose(fieldtype1val);
1917  H5Tclose(fieldtype1key);
1918  H5Tclose(item_type0);
1919  H5Tclose(fieldtype0);
1920  break;
1921 
1922  }
1923  case VL_MAP_INT_DOUBLE: {
1924  unsigned int total_size0=CYCLUS_SHA1_SIZE;
1925  std::map<int, double> x0;
1926  x0=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(buf+offset);
1927  is_row_selected=CmpConds<std::map<int, double>>(&x0, &(field_conds[qr.fields[j]]));
1928  if(is_row_selected){
1929  row[j]=x0;
1930 
1931  }
1932  break;
1933 
1934  }
1935  case MAP_INT_STRING: {
1936  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1937  unsigned int total_size0=H5Tget_size(fieldtype0);
1938  hsize_t fieldlen0;
1939  H5Tget_array_dims2(fieldtype0, &fieldlen0);
1940  hid_t item_type0=H5Tget_super(fieldtype0);
1941  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
1942  unsigned int total_size1key=H5Tget_size(fieldtype1key);
1943  size_t nullpos1val;
1944  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
1945  unsigned int total_size1val=H5Tget_size(fieldtype1val);
1946  std::map<int, std::string> x0;
1947  for(unsigned int k0=0;k0<fieldlen0;++k0){
1948  int x1key;
1949  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
1950  std::string x1val;
1951  x1val=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size1val);
1952  nullpos1val=x1val.find('\0');
1953  if(nullpos1val!=std::string::npos){
1954  x1val.resize(nullpos1val);
1955 
1956  }
1957  x0[x1key]=x1val;
1958 
1959  }
1960  is_row_selected=CmpConds<std::map<int, std::string>>(&x0, &(field_conds[qr.fields[j]]));
1961  if(is_row_selected){
1962  row[j]=x0;
1963 
1964  }
1965  H5Tclose(fieldtype1val);
1966  H5Tclose(fieldtype1key);
1967  H5Tclose(item_type0);
1968  H5Tclose(fieldtype0);
1969  break;
1970 
1971  }
1972  case VL_MAP_INT_STRING: {
1973  unsigned int total_size0=CYCLUS_SHA1_SIZE;
1974  std::map<int, std::string> x0;
1975  x0=VLRead<std::map<int, std::string>,VL_MAP_INT_STRING>(buf+offset);
1976  is_row_selected=CmpConds<std::map<int, std::string>>(&x0, &(field_conds[qr.fields[j]]));
1977  if(is_row_selected){
1978  row[j]=x0;
1979 
1980  }
1981  break;
1982 
1983  }
1984  case MAP_INT_VL_STRING: {
1985  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
1986  unsigned int total_size0=H5Tget_size(fieldtype0);
1987  hsize_t fieldlen0;
1988  H5Tget_array_dims2(fieldtype0, &fieldlen0);
1989  hid_t item_type0=H5Tget_super(fieldtype0);
1990  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
1991  unsigned int total_size1key=H5Tget_size(fieldtype1key);
1992  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
1993  unsigned int total_size1val=H5Tget_size(fieldtype1val);
1994  std::map<int, std::string> x0;
1995  for(unsigned int k0=0;k0<fieldlen0;++k0){
1996  int x1key;
1997  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
1998  std::string x1val;
1999  x1val=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2000  x0[x1key]=x1val;
2001 
2002  }
2003  is_row_selected=CmpConds<std::map<int, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2004  if(is_row_selected){
2005  row[j]=x0;
2006 
2007  }
2008  H5Tclose(fieldtype1val);
2009  H5Tclose(fieldtype1key);
2010  H5Tclose(item_type0);
2011  H5Tclose(fieldtype0);
2012  break;
2013 
2014  }
2015  case VL_MAP_INT_VL_STRING: {
2016  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2017  std::map<int, std::string> x0;
2018  x0=VLRead<std::map<int, std::string>,VL_MAP_INT_VL_STRING>(buf+offset);
2019  is_row_selected=CmpConds<std::map<int, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2020  if(is_row_selected){
2021  row[j]=x0;
2022 
2023  }
2024  break;
2025 
2026  }
2027  case MAP_INT_BLOB: {
2028  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2029  unsigned int total_size0=H5Tget_size(fieldtype0);
2030  hsize_t fieldlen0;
2031  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2032  hid_t item_type0=H5Tget_super(fieldtype0);
2033  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2034  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2035  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2036  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2037  std::map<int, cyclus::Blob> x0;
2038  for(unsigned int k0=0;k0<fieldlen0;++k0){
2039  int x1key;
2040  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
2041  cyclus::Blob x1val;
2042  x1val=VLRead<cyclus::Blob,BLOB>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2043  x0[x1key]=x1val;
2044 
2045  }
2046  is_row_selected=CmpConds<std::map<int, cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
2047  if(is_row_selected){
2048  row[j]=x0;
2049 
2050  }
2051  H5Tclose(fieldtype1val);
2052  H5Tclose(fieldtype1key);
2053  H5Tclose(item_type0);
2054  H5Tclose(fieldtype0);
2055  break;
2056 
2057  }
2058  case VL_MAP_INT_BLOB: {
2059  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2060  std::map<int, cyclus::Blob> x0;
2061  x0=VLRead<std::map<int, cyclus::Blob>,VL_MAP_INT_BLOB>(buf+offset);
2062  is_row_selected=CmpConds<std::map<int, cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
2063  if(is_row_selected){
2064  row[j]=x0;
2065 
2066  }
2067  break;
2068 
2069  }
2070  case MAP_INT_UUID: {
2071  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2072  unsigned int total_size0=H5Tget_size(fieldtype0);
2073  hsize_t fieldlen0;
2074  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2075  hid_t item_type0=H5Tget_super(fieldtype0);
2076  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2077  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2078  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2079  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2080  std::map<int, boost::uuids::uuid> x0;
2081  for(unsigned int k0=0;k0<fieldlen0;++k0){
2082  int x1key;
2083  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
2084  boost::uuids::uuid x1val;
2085  memcpy(&x1val, buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size1val);
2086  x0[x1key]=x1val;
2087 
2088  }
2089  is_row_selected=CmpConds<std::map<int, boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
2090  if(is_row_selected){
2091  row[j]=x0;
2092 
2093  }
2094  H5Tclose(fieldtype1val);
2095  H5Tclose(fieldtype1key);
2096  H5Tclose(item_type0);
2097  H5Tclose(fieldtype0);
2098  break;
2099 
2100  }
2101  case VL_MAP_INT_UUID: {
2102  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2103  std::map<int, boost::uuids::uuid> x0;
2104  x0=VLRead<std::map<int, boost::uuids::uuid>,VL_MAP_INT_UUID>(buf+offset);
2105  is_row_selected=CmpConds<std::map<int, boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
2106  if(is_row_selected){
2107  row[j]=x0;
2108 
2109  }
2110  break;
2111 
2112  }
2113  case MAP_STRING_BOOL: {
2114  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2115  unsigned int total_size0=H5Tget_size(fieldtype0);
2116  hsize_t fieldlen0;
2117  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2118  hid_t item_type0=H5Tget_super(fieldtype0);
2119  size_t nullpos1key;
2120  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2121  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2122  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2123  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2124  std::map<std::string, bool> x0;
2125  for(unsigned int k0=0;k0<fieldlen0;++k0){
2126  std::string x1key;
2127  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
2128  nullpos1key=x1key.find('\0');
2129  if(nullpos1key!=std::string::npos){
2130  x1key.resize(nullpos1key);
2131 
2132  }
2133  bool x1val;
2134  x1val=*reinterpret_cast<bool*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2135  x0[x1key]=x1val;
2136 
2137  }
2138  is_row_selected=CmpConds<std::map<std::string, bool>>(&x0, &(field_conds[qr.fields[j]]));
2139  if(is_row_selected){
2140  row[j]=x0;
2141 
2142  }
2143  H5Tclose(fieldtype1val);
2144  H5Tclose(fieldtype1key);
2145  H5Tclose(item_type0);
2146  H5Tclose(fieldtype0);
2147  break;
2148 
2149  }
2150  case VL_MAP_STRING_BOOL: {
2151  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2152  std::map<std::string, bool> x0;
2153  x0=VLRead<std::map<std::string, bool>,VL_MAP_STRING_BOOL>(buf+offset);
2154  is_row_selected=CmpConds<std::map<std::string, bool>>(&x0, &(field_conds[qr.fields[j]]));
2155  if(is_row_selected){
2156  row[j]=x0;
2157 
2158  }
2159  break;
2160 
2161  }
2162  case MAP_STRING_INT: {
2163  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2164  unsigned int total_size0=H5Tget_size(fieldtype0);
2165  hsize_t fieldlen0;
2166  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2167  hid_t item_type0=H5Tget_super(fieldtype0);
2168  size_t nullpos1key;
2169  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2170  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2171  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2172  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2173  std::map<std::string, int> x0;
2174  for(unsigned int k0=0;k0<fieldlen0;++k0){
2175  std::string x1key;
2176  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
2177  nullpos1key=x1key.find('\0');
2178  if(nullpos1key!=std::string::npos){
2179  x1key.resize(nullpos1key);
2180 
2181  }
2182  int x1val;
2183  x1val=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2184  x0[x1key]=x1val;
2185 
2186  }
2187  is_row_selected=CmpConds<std::map<std::string, int>>(&x0, &(field_conds[qr.fields[j]]));
2188  if(is_row_selected){
2189  row[j]=x0;
2190 
2191  }
2192  H5Tclose(fieldtype1val);
2193  H5Tclose(fieldtype1key);
2194  H5Tclose(item_type0);
2195  H5Tclose(fieldtype0);
2196  break;
2197 
2198  }
2199  case VL_MAP_STRING_INT: {
2200  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2201  std::map<std::string, int> x0;
2202  x0=VLRead<std::map<std::string, int>,VL_MAP_STRING_INT>(buf+offset);
2203  is_row_selected=CmpConds<std::map<std::string, int>>(&x0, &(field_conds[qr.fields[j]]));
2204  if(is_row_selected){
2205  row[j]=x0;
2206 
2207  }
2208  break;
2209 
2210  }
2211  case MAP_STRING_FLOAT: {
2212  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2213  unsigned int total_size0=H5Tget_size(fieldtype0);
2214  hsize_t fieldlen0;
2215  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2216  hid_t item_type0=H5Tget_super(fieldtype0);
2217  size_t nullpos1key;
2218  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2219  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2220  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2221  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2222  std::map<std::string, float> x0;
2223  for(unsigned int k0=0;k0<fieldlen0;++k0){
2224  std::string x1key;
2225  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
2226  nullpos1key=x1key.find('\0');
2227  if(nullpos1key!=std::string::npos){
2228  x1key.resize(nullpos1key);
2229 
2230  }
2231  float x1val;
2232  x1val=*reinterpret_cast<float*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2233  x0[x1key]=x1val;
2234 
2235  }
2236  is_row_selected=CmpConds<std::map<std::string, float>>(&x0, &(field_conds[qr.fields[j]]));
2237  if(is_row_selected){
2238  row[j]=x0;
2239 
2240  }
2241  H5Tclose(fieldtype1val);
2242  H5Tclose(fieldtype1key);
2243  H5Tclose(item_type0);
2244  H5Tclose(fieldtype0);
2245  break;
2246 
2247  }
2248  case VL_MAP_STRING_FLOAT: {
2249  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2250  std::map<std::string, float> x0;
2251  x0=VLRead<std::map<std::string, float>,VL_MAP_STRING_FLOAT>(buf+offset);
2252  is_row_selected=CmpConds<std::map<std::string, float>>(&x0, &(field_conds[qr.fields[j]]));
2253  if(is_row_selected){
2254  row[j]=x0;
2255 
2256  }
2257  break;
2258 
2259  }
2260  case MAP_STRING_DOUBLE: {
2261  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2262  unsigned int total_size0=H5Tget_size(fieldtype0);
2263  hsize_t fieldlen0;
2264  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2265  hid_t item_type0=H5Tget_super(fieldtype0);
2266  size_t nullpos1key;
2267  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2268  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2269  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2270  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2271  std::map<std::string, double> x0;
2272  for(unsigned int k0=0;k0<fieldlen0;++k0){
2273  std::string x1key;
2274  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
2275  nullpos1key=x1key.find('\0');
2276  if(nullpos1key!=std::string::npos){
2277  x1key.resize(nullpos1key);
2278 
2279  }
2280  double x1val;
2281  x1val=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2282  x0[x1key]=x1val;
2283 
2284  }
2285  is_row_selected=CmpConds<std::map<std::string, double>>(&x0, &(field_conds[qr.fields[j]]));
2286  if(is_row_selected){
2287  row[j]=x0;
2288 
2289  }
2290  H5Tclose(fieldtype1val);
2291  H5Tclose(fieldtype1key);
2292  H5Tclose(item_type0);
2293  H5Tclose(fieldtype0);
2294  break;
2295 
2296  }
2297  case VL_MAP_STRING_DOUBLE: {
2298  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2299  std::map<std::string, double> x0;
2300  x0=VLRead<std::map<std::string, double>,VL_MAP_STRING_DOUBLE>(buf+offset);
2301  is_row_selected=CmpConds<std::map<std::string, double>>(&x0, &(field_conds[qr.fields[j]]));
2302  if(is_row_selected){
2303  row[j]=x0;
2304 
2305  }
2306  break;
2307 
2308  }
2309  case MAP_STRING_STRING: {
2310  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2311  unsigned int total_size0=H5Tget_size(fieldtype0);
2312  hsize_t fieldlen0;
2313  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2314  hid_t item_type0=H5Tget_super(fieldtype0);
2315  size_t nullpos1key;
2316  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2317  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2318  size_t nullpos1val;
2319  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2320  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2321  std::map<std::string, std::string> x0;
2322  for(unsigned int k0=0;k0<fieldlen0;++k0){
2323  std::string x1key;
2324  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
2325  nullpos1key=x1key.find('\0');
2326  if(nullpos1key!=std::string::npos){
2327  x1key.resize(nullpos1key);
2328 
2329  }
2330  std::string x1val;
2331  x1val=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size1val);
2332  nullpos1val=x1val.find('\0');
2333  if(nullpos1val!=std::string::npos){
2334  x1val.resize(nullpos1val);
2335 
2336  }
2337  x0[x1key]=x1val;
2338 
2339  }
2340  is_row_selected=CmpConds<std::map<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2341  if(is_row_selected){
2342  row[j]=x0;
2343 
2344  }
2345  H5Tclose(fieldtype1val);
2346  H5Tclose(fieldtype1key);
2347  H5Tclose(item_type0);
2348  H5Tclose(fieldtype0);
2349  break;
2350 
2351  }
2352  case VL_MAP_STRING_STRING: {
2353  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2354  std::map<std::string, std::string> x0;
2355  x0=VLRead<std::map<std::string, std::string>,VL_MAP_STRING_STRING>(buf+offset);
2356  is_row_selected=CmpConds<std::map<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2357  if(is_row_selected){
2358  row[j]=x0;
2359 
2360  }
2361  break;
2362 
2363  }
2364  case MAP_STRING_VL_STRING: {
2365  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2366  unsigned int total_size0=H5Tget_size(fieldtype0);
2367  hsize_t fieldlen0;
2368  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2369  hid_t item_type0=H5Tget_super(fieldtype0);
2370  size_t nullpos1key;
2371  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2372  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2373  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2374  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2375  std::map<std::string, std::string> x0;
2376  for(unsigned int k0=0;k0<fieldlen0;++k0){
2377  std::string x1key;
2378  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
2379  nullpos1key=x1key.find('\0');
2380  if(nullpos1key!=std::string::npos){
2381  x1key.resize(nullpos1key);
2382 
2383  }
2384  std::string x1val;
2385  x1val=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2386  x0[x1key]=x1val;
2387 
2388  }
2389  is_row_selected=CmpConds<std::map<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2390  if(is_row_selected){
2391  row[j]=x0;
2392 
2393  }
2394  H5Tclose(fieldtype1val);
2395  H5Tclose(fieldtype1key);
2396  H5Tclose(item_type0);
2397  H5Tclose(fieldtype0);
2398  break;
2399 
2400  }
2401  case VL_MAP_STRING_VL_STRING: {
2402  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2403  std::map<std::string, std::string> x0;
2404  x0=VLRead<std::map<std::string, std::string>,VL_MAP_STRING_VL_STRING>(buf+offset);
2405  is_row_selected=CmpConds<std::map<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2406  if(is_row_selected){
2407  row[j]=x0;
2408 
2409  }
2410  break;
2411 
2412  }
2413  case MAP_STRING_BLOB: {
2414  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2415  unsigned int total_size0=H5Tget_size(fieldtype0);
2416  hsize_t fieldlen0;
2417  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2418  hid_t item_type0=H5Tget_super(fieldtype0);
2419  size_t nullpos1key;
2420  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2421  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2422  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2423  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2424  std::map<std::string, cyclus::Blob> x0;
2425  for(unsigned int k0=0;k0<fieldlen0;++k0){
2426  std::string x1key;
2427  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
2428  nullpos1key=x1key.find('\0');
2429  if(nullpos1key!=std::string::npos){
2430  x1key.resize(nullpos1key);
2431 
2432  }
2433  cyclus::Blob x1val;
2434  x1val=VLRead<cyclus::Blob,BLOB>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2435  x0[x1key]=x1val;
2436 
2437  }
2438  is_row_selected=CmpConds<std::map<std::string, cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
2439  if(is_row_selected){
2440  row[j]=x0;
2441 
2442  }
2443  H5Tclose(fieldtype1val);
2444  H5Tclose(fieldtype1key);
2445  H5Tclose(item_type0);
2446  H5Tclose(fieldtype0);
2447  break;
2448 
2449  }
2450  case VL_MAP_STRING_BLOB: {
2451  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2452  std::map<std::string, cyclus::Blob> x0;
2453  x0=VLRead<std::map<std::string, cyclus::Blob>,VL_MAP_STRING_BLOB>(buf+offset);
2454  is_row_selected=CmpConds<std::map<std::string, cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
2455  if(is_row_selected){
2456  row[j]=x0;
2457 
2458  }
2459  break;
2460 
2461  }
2462  case MAP_STRING_UUID: {
2463  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2464  unsigned int total_size0=H5Tget_size(fieldtype0);
2465  hsize_t fieldlen0;
2466  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2467  hid_t item_type0=H5Tget_super(fieldtype0);
2468  size_t nullpos1key;
2469  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2470  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2471  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2472  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2473  std::map<std::string, boost::uuids::uuid> x0;
2474  for(unsigned int k0=0;k0<fieldlen0;++k0){
2475  std::string x1key;
2476  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
2477  nullpos1key=x1key.find('\0');
2478  if(nullpos1key!=std::string::npos){
2479  x1key.resize(nullpos1key);
2480 
2481  }
2482  boost::uuids::uuid x1val;
2483  memcpy(&x1val, buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size1val);
2484  x0[x1key]=x1val;
2485 
2486  }
2487  is_row_selected=CmpConds<std::map<std::string, boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
2488  if(is_row_selected){
2489  row[j]=x0;
2490 
2491  }
2492  H5Tclose(fieldtype1val);
2493  H5Tclose(fieldtype1key);
2494  H5Tclose(item_type0);
2495  H5Tclose(fieldtype0);
2496  break;
2497 
2498  }
2499  case VL_MAP_STRING_UUID: {
2500  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2501  std::map<std::string, boost::uuids::uuid> x0;
2502  x0=VLRead<std::map<std::string, boost::uuids::uuid>,VL_MAP_STRING_UUID>(buf+offset);
2503  is_row_selected=CmpConds<std::map<std::string, boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
2504  if(is_row_selected){
2505  row[j]=x0;
2506 
2507  }
2508  break;
2509 
2510  }
2511  case MAP_VL_STRING_BOOL: {
2512  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2513  unsigned int total_size0=H5Tget_size(fieldtype0);
2514  hsize_t fieldlen0;
2515  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2516  hid_t item_type0=H5Tget_super(fieldtype0);
2517  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2518  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2519  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2520  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2521  std::map<std::string, bool> x0;
2522  for(unsigned int k0=0;k0<fieldlen0;++k0){
2523  std::string x1key;
2524  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
2525  bool x1val;
2526  x1val=*reinterpret_cast<bool*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2527  x0[x1key]=x1val;
2528 
2529  }
2530  is_row_selected=CmpConds<std::map<std::string, bool>>(&x0, &(field_conds[qr.fields[j]]));
2531  if(is_row_selected){
2532  row[j]=x0;
2533 
2534  }
2535  H5Tclose(fieldtype1val);
2536  H5Tclose(fieldtype1key);
2537  H5Tclose(item_type0);
2538  H5Tclose(fieldtype0);
2539  break;
2540 
2541  }
2542  case VL_MAP_VL_STRING_BOOL: {
2543  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2544  std::map<std::string, bool> x0;
2545  x0=VLRead<std::map<std::string, bool>,VL_MAP_VL_STRING_BOOL>(buf+offset);
2546  is_row_selected=CmpConds<std::map<std::string, bool>>(&x0, &(field_conds[qr.fields[j]]));
2547  if(is_row_selected){
2548  row[j]=x0;
2549 
2550  }
2551  break;
2552 
2553  }
2554  case MAP_VL_STRING_INT: {
2555  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2556  unsigned int total_size0=H5Tget_size(fieldtype0);
2557  hsize_t fieldlen0;
2558  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2559  hid_t item_type0=H5Tget_super(fieldtype0);
2560  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2561  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2562  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2563  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2564  std::map<std::string, int> x0;
2565  for(unsigned int k0=0;k0<fieldlen0;++k0){
2566  std::string x1key;
2567  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
2568  int x1val;
2569  x1val=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2570  x0[x1key]=x1val;
2571 
2572  }
2573  is_row_selected=CmpConds<std::map<std::string, int>>(&x0, &(field_conds[qr.fields[j]]));
2574  if(is_row_selected){
2575  row[j]=x0;
2576 
2577  }
2578  H5Tclose(fieldtype1val);
2579  H5Tclose(fieldtype1key);
2580  H5Tclose(item_type0);
2581  H5Tclose(fieldtype0);
2582  break;
2583 
2584  }
2585  case VL_MAP_VL_STRING_INT: {
2586  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2587  std::map<std::string, int> x0;
2588  x0=VLRead<std::map<std::string, int>,VL_MAP_VL_STRING_INT>(buf+offset);
2589  is_row_selected=CmpConds<std::map<std::string, int>>(&x0, &(field_conds[qr.fields[j]]));
2590  if(is_row_selected){
2591  row[j]=x0;
2592 
2593  }
2594  break;
2595 
2596  }
2597  case MAP_VL_STRING_FLOAT: {
2598  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2599  unsigned int total_size0=H5Tget_size(fieldtype0);
2600  hsize_t fieldlen0;
2601  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2602  hid_t item_type0=H5Tget_super(fieldtype0);
2603  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2604  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2605  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2606  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2607  std::map<std::string, float> x0;
2608  for(unsigned int k0=0;k0<fieldlen0;++k0){
2609  std::string x1key;
2610  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
2611  float x1val;
2612  x1val=*reinterpret_cast<float*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2613  x0[x1key]=x1val;
2614 
2615  }
2616  is_row_selected=CmpConds<std::map<std::string, float>>(&x0, &(field_conds[qr.fields[j]]));
2617  if(is_row_selected){
2618  row[j]=x0;
2619 
2620  }
2621  H5Tclose(fieldtype1val);
2622  H5Tclose(fieldtype1key);
2623  H5Tclose(item_type0);
2624  H5Tclose(fieldtype0);
2625  break;
2626 
2627  }
2628  case VL_MAP_VL_STRING_FLOAT: {
2629  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2630  std::map<std::string, float> x0;
2631  x0=VLRead<std::map<std::string, float>,VL_MAP_VL_STRING_FLOAT>(buf+offset);
2632  is_row_selected=CmpConds<std::map<std::string, float>>(&x0, &(field_conds[qr.fields[j]]));
2633  if(is_row_selected){
2634  row[j]=x0;
2635 
2636  }
2637  break;
2638 
2639  }
2640  case MAP_VL_STRING_DOUBLE: {
2641  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2642  unsigned int total_size0=H5Tget_size(fieldtype0);
2643  hsize_t fieldlen0;
2644  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2645  hid_t item_type0=H5Tget_super(fieldtype0);
2646  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2647  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2648  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2649  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2650  std::map<std::string, double> x0;
2651  for(unsigned int k0=0;k0<fieldlen0;++k0){
2652  std::string x1key;
2653  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
2654  double x1val;
2655  x1val=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2656  x0[x1key]=x1val;
2657 
2658  }
2659  is_row_selected=CmpConds<std::map<std::string, double>>(&x0, &(field_conds[qr.fields[j]]));
2660  if(is_row_selected){
2661  row[j]=x0;
2662 
2663  }
2664  H5Tclose(fieldtype1val);
2665  H5Tclose(fieldtype1key);
2666  H5Tclose(item_type0);
2667  H5Tclose(fieldtype0);
2668  break;
2669 
2670  }
2671  case VL_MAP_VL_STRING_DOUBLE: {
2672  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2673  std::map<std::string, double> x0;
2674  x0=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(buf+offset);
2675  is_row_selected=CmpConds<std::map<std::string, double>>(&x0, &(field_conds[qr.fields[j]]));
2676  if(is_row_selected){
2677  row[j]=x0;
2678 
2679  }
2680  break;
2681 
2682  }
2683  case MAP_VL_STRING_STRING: {
2684  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2685  unsigned int total_size0=H5Tget_size(fieldtype0);
2686  hsize_t fieldlen0;
2687  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2688  hid_t item_type0=H5Tget_super(fieldtype0);
2689  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2690  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2691  size_t nullpos1val;
2692  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2693  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2694  std::map<std::string, std::string> x0;
2695  for(unsigned int k0=0;k0<fieldlen0;++k0){
2696  std::string x1key;
2697  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
2698  std::string x1val;
2699  x1val=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size1val);
2700  nullpos1val=x1val.find('\0');
2701  if(nullpos1val!=std::string::npos){
2702  x1val.resize(nullpos1val);
2703 
2704  }
2705  x0[x1key]=x1val;
2706 
2707  }
2708  is_row_selected=CmpConds<std::map<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2709  if(is_row_selected){
2710  row[j]=x0;
2711 
2712  }
2713  H5Tclose(fieldtype1val);
2714  H5Tclose(fieldtype1key);
2715  H5Tclose(item_type0);
2716  H5Tclose(fieldtype0);
2717  break;
2718 
2719  }
2720  case VL_MAP_VL_STRING_STRING: {
2721  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2722  std::map<std::string, std::string> x0;
2723  x0=VLRead<std::map<std::string, std::string>,VL_MAP_VL_STRING_STRING>(buf+offset);
2724  is_row_selected=CmpConds<std::map<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2725  if(is_row_selected){
2726  row[j]=x0;
2727 
2728  }
2729  break;
2730 
2731  }
2732  case MAP_VL_STRING_VL_STRING: {
2733  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2734  unsigned int total_size0=H5Tget_size(fieldtype0);
2735  hsize_t fieldlen0;
2736  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2737  hid_t item_type0=H5Tget_super(fieldtype0);
2738  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2739  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2740  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2741  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2742  std::map<std::string, std::string> x0;
2743  for(unsigned int k0=0;k0<fieldlen0;++k0){
2744  std::string x1key;
2745  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
2746  std::string x1val;
2747  x1val=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2748  x0[x1key]=x1val;
2749 
2750  }
2751  is_row_selected=CmpConds<std::map<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2752  if(is_row_selected){
2753  row[j]=x0;
2754 
2755  }
2756  H5Tclose(fieldtype1val);
2757  H5Tclose(fieldtype1key);
2758  H5Tclose(item_type0);
2759  H5Tclose(fieldtype0);
2760  break;
2761 
2762  }
2764  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2765  std::map<std::string, std::string> x0;
2766  x0=VLRead<std::map<std::string, std::string>,VL_MAP_VL_STRING_VL_STRING>(buf+offset);
2767  is_row_selected=CmpConds<std::map<std::string, std::string>>(&x0, &(field_conds[qr.fields[j]]));
2768  if(is_row_selected){
2769  row[j]=x0;
2770 
2771  }
2772  break;
2773 
2774  }
2775  case MAP_VL_STRING_BLOB: {
2776  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2777  unsigned int total_size0=H5Tget_size(fieldtype0);
2778  hsize_t fieldlen0;
2779  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2780  hid_t item_type0=H5Tget_super(fieldtype0);
2781  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2782  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2783  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2784  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2785  std::map<std::string, cyclus::Blob> x0;
2786  for(unsigned int k0=0;k0<fieldlen0;++k0){
2787  std::string x1key;
2788  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
2789  cyclus::Blob x1val;
2790  x1val=VLRead<cyclus::Blob,BLOB>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2791  x0[x1key]=x1val;
2792 
2793  }
2794  is_row_selected=CmpConds<std::map<std::string, cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
2795  if(is_row_selected){
2796  row[j]=x0;
2797 
2798  }
2799  H5Tclose(fieldtype1val);
2800  H5Tclose(fieldtype1key);
2801  H5Tclose(item_type0);
2802  H5Tclose(fieldtype0);
2803  break;
2804 
2805  }
2806  case VL_MAP_VL_STRING_BLOB: {
2807  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2808  std::map<std::string, cyclus::Blob> x0;
2809  x0=VLRead<std::map<std::string, cyclus::Blob>,VL_MAP_VL_STRING_BLOB>(buf+offset);
2810  is_row_selected=CmpConds<std::map<std::string, cyclus::Blob>>(&x0, &(field_conds[qr.fields[j]]));
2811  if(is_row_selected){
2812  row[j]=x0;
2813 
2814  }
2815  break;
2816 
2817  }
2818  case MAP_VL_STRING_UUID: {
2819  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2820  unsigned int total_size0=H5Tget_size(fieldtype0);
2821  hsize_t fieldlen0;
2822  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2823  hid_t item_type0=H5Tget_super(fieldtype0);
2824  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2825  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2826  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2827  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2828  std::map<std::string, boost::uuids::uuid> x0;
2829  for(unsigned int k0=0;k0<fieldlen0;++k0){
2830  std::string x1key;
2831  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
2832  boost::uuids::uuid x1val;
2833  memcpy(&x1val, buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size1val);
2834  x0[x1key]=x1val;
2835 
2836  }
2837  is_row_selected=CmpConds<std::map<std::string, boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
2838  if(is_row_selected){
2839  row[j]=x0;
2840 
2841  }
2842  H5Tclose(fieldtype1val);
2843  H5Tclose(fieldtype1key);
2844  H5Tclose(item_type0);
2845  H5Tclose(fieldtype0);
2846  break;
2847 
2848  }
2849  case VL_MAP_VL_STRING_UUID: {
2850  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2851  std::map<std::string, boost::uuids::uuid> x0;
2852  x0=VLRead<std::map<std::string, boost::uuids::uuid>,VL_MAP_VL_STRING_UUID>(buf+offset);
2853  is_row_selected=CmpConds<std::map<std::string, boost::uuids::uuid>>(&x0, &(field_conds[qr.fields[j]]));
2854  if(is_row_selected){
2855  row[j]=x0;
2856 
2857  }
2858  break;
2859 
2860  }
2862  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2863  unsigned int total_size0=H5Tget_size(fieldtype0);
2864  hsize_t fieldlen0;
2865  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2866  hid_t item_type0=H5Tget_super(fieldtype0);
2867  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2868  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2869  hid_t fieldtype2keyfirst=H5Tget_member_type(fieldtype1key, 0);
2870  unsigned int total_size2keyfirst=H5Tget_size(fieldtype2keyfirst);
2871  size_t nullpos2keysecond;
2872  hid_t fieldtype2keysecond=H5Tget_member_type(fieldtype1key, 1);
2873  unsigned int total_size2keysecond=H5Tget_size(fieldtype2keysecond);
2874  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2875  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2876  std::map<std::pair<int, std::string>, double> x0;
2877  for(unsigned int k0=0;k0<fieldlen0;++k0){
2878  std::pair<int, std::string> x1key;
2879  int x2keyfirst;
2880  x2keyfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
2881  std::string x2keysecond;
2882  x2keysecond=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size2keyfirst, total_size2keysecond);
2883  nullpos2keysecond=x2keysecond.find('\0');
2884  if(nullpos2keysecond!=std::string::npos){
2885  x2keysecond.resize(nullpos2keysecond);
2886 
2887  }
2888  x1key=std::make_pair(x2keyfirst, x2keysecond);
2889  double x1val;
2890  x1val=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2891  x0[x1key]=x1val;
2892 
2893  }
2894  is_row_selected=CmpConds<std::map<std::pair<int, std::string>, double>>(&x0, &(field_conds[qr.fields[j]]));
2895  if(is_row_selected){
2896  row[j]=x0;
2897 
2898  }
2899  H5Tclose(fieldtype1val);
2900  H5Tclose(fieldtype2keysecond);
2901  H5Tclose(fieldtype2keyfirst);
2902  H5Tclose(fieldtype1key);
2903  H5Tclose(item_type0);
2904  H5Tclose(fieldtype0);
2905  break;
2906 
2907  }
2909  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2910  std::map<std::pair<int, std::string>, double> x0;
2911  x0=VLRead<std::map<std::pair<int, std::string>, double>,VL_MAP_PAIR_INT_STRING_DOUBLE>(buf+offset);
2912  is_row_selected=CmpConds<std::map<std::pair<int, std::string>, double>>(&x0, &(field_conds[qr.fields[j]]));
2913  if(is_row_selected){
2914  row[j]=x0;
2915 
2916  }
2917  break;
2918 
2919  }
2921  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2922  unsigned int total_size0=H5Tget_size(fieldtype0);
2923  hsize_t fieldlen0;
2924  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2925  hid_t item_type0=H5Tget_super(fieldtype0);
2926  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2927  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2928  hid_t fieldtype2keyfirst=H5Tget_member_type(fieldtype1key, 0);
2929  unsigned int total_size2keyfirst=H5Tget_size(fieldtype2keyfirst);
2930  hid_t fieldtype2keysecond=H5Tget_member_type(fieldtype1key, 1);
2931  unsigned int total_size2keysecond=H5Tget_size(fieldtype2keysecond);
2932  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2933  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2934  std::map<std::pair<int, std::string>, double> x0;
2935  for(unsigned int k0=0;k0<fieldlen0;++k0){
2936  std::pair<int, std::string> x1key;
2937  int x2keyfirst;
2938  x2keyfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
2939  std::string x2keysecond;
2940  x2keysecond=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size2keyfirst);
2941  x1key=std::make_pair(x2keyfirst, x2keysecond);
2942  double x1val;
2943  x1val=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
2944  x0[x1key]=x1val;
2945 
2946  }
2947  is_row_selected=CmpConds<std::map<std::pair<int, std::string>, double>>(&x0, &(field_conds[qr.fields[j]]));
2948  if(is_row_selected){
2949  row[j]=x0;
2950 
2951  }
2952  H5Tclose(fieldtype1val);
2953  H5Tclose(fieldtype2keysecond);
2954  H5Tclose(fieldtype2keyfirst);
2955  H5Tclose(fieldtype1key);
2956  H5Tclose(item_type0);
2957  H5Tclose(fieldtype0);
2958  break;
2959 
2960  }
2962  unsigned int total_size0=CYCLUS_SHA1_SIZE;
2963  std::map<std::pair<int, std::string>, double> x0;
2964  x0=VLRead<std::map<std::pair<int, std::string>, double>,VL_MAP_PAIR_INT_VL_STRING_DOUBLE>(buf+offset);
2965  is_row_selected=CmpConds<std::map<std::pair<int, std::string>, double>>(&x0, &(field_conds[qr.fields[j]]));
2966  if(is_row_selected){
2967  row[j]=x0;
2968 
2969  }
2970  break;
2971 
2972  }
2973  case MAP_STRING_VECTOR_DOUBLE: {
2974  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
2975  unsigned int total_size0=H5Tget_size(fieldtype0);
2976  hsize_t fieldlen0;
2977  H5Tget_array_dims2(fieldtype0, &fieldlen0);
2978  hid_t item_type0=H5Tget_super(fieldtype0);
2979  size_t nullpos1key;
2980  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
2981  unsigned int total_size1key=H5Tget_size(fieldtype1key);
2982  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
2983  unsigned int total_size1val=H5Tget_size(fieldtype1val);
2984  hsize_t fieldlen1val;
2985  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
2986  hid_t item_type1val=H5Tget_super(fieldtype1val);
2987  unsigned int total_size2valelem=H5Tget_size(item_type1val);
2988  std::map<std::string, std::vector<double>> x0;
2989  for(unsigned int k0=0;k0<fieldlen0;++k0){
2990  std::string x1key;
2991  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
2992  nullpos1key=x1key.find('\0');
2993  if(nullpos1key!=std::string::npos){
2994  x1key.resize(nullpos1key);
2995 
2996  }
2997  std::vector<double> x1val;
2998  x1val=std::vector<double>(fieldlen1val);
2999  memcpy(&x1val[0], buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size1val);
3000  x0[x1key]=x1val;
3001 
3002  }
3003  is_row_selected=CmpConds<std::map<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
3004  if(is_row_selected){
3005  row[j]=x0;
3006 
3007  }
3008  H5Tclose(item_type1val);
3009  H5Tclose(fieldtype1val);
3010  H5Tclose(fieldtype1key);
3011  H5Tclose(item_type0);
3012  H5Tclose(fieldtype0);
3013  break;
3014 
3015  }
3017  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3018  unsigned int total_size0=H5Tget_size(fieldtype0);
3019  hsize_t fieldlen0;
3020  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3021  hid_t item_type0=H5Tget_super(fieldtype0);
3022  size_t nullpos1key;
3023  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3024  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3025  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
3026  std::map<std::string, std::vector<double>> x0;
3027  for(unsigned int k0=0;k0<fieldlen0;++k0){
3028  std::string x1key;
3029  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
3030  nullpos1key=x1key.find('\0');
3031  if(nullpos1key!=std::string::npos){
3032  x1key.resize(nullpos1key);
3033 
3034  }
3035  std::vector<double> x1val;
3036  x1val=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3037  x0[x1key]=x1val;
3038 
3039  }
3040  is_row_selected=CmpConds<std::map<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
3041  if(is_row_selected){
3042  row[j]=x0;
3043 
3044  }
3045  H5Tclose(fieldtype1key);
3046  H5Tclose(item_type0);
3047  H5Tclose(fieldtype0);
3048  break;
3049 
3050  }
3052  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3053  std::map<std::string, std::vector<double>> x0;
3054  x0=VLRead<std::map<std::string, std::vector<double>>,VL_MAP_STRING_VECTOR_DOUBLE>(buf+offset);
3055  is_row_selected=CmpConds<std::map<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
3056  if(is_row_selected){
3057  row[j]=x0;
3058 
3059  }
3060  break;
3061 
3062  }
3064  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3065  unsigned int total_size0=H5Tget_size(fieldtype0);
3066  hsize_t fieldlen0;
3067  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3068  hid_t item_type0=H5Tget_super(fieldtype0);
3069  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3070  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3071  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3072  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3073  hsize_t fieldlen1val;
3074  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
3075  hid_t item_type1val=H5Tget_super(fieldtype1val);
3076  unsigned int total_size2valelem=H5Tget_size(item_type1val);
3077  std::map<std::string, std::vector<double>> x0;
3078  for(unsigned int k0=0;k0<fieldlen0;++k0){
3079  std::string x1key;
3080  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
3081  std::vector<double> x1val;
3082  x1val=std::vector<double>(fieldlen1val);
3083  memcpy(&x1val[0], buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size1val);
3084  x0[x1key]=x1val;
3085 
3086  }
3087  is_row_selected=CmpConds<std::map<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
3088  if(is_row_selected){
3089  row[j]=x0;
3090 
3091  }
3092  H5Tclose(item_type1val);
3093  H5Tclose(fieldtype1val);
3094  H5Tclose(fieldtype1key);
3095  H5Tclose(item_type0);
3096  H5Tclose(fieldtype0);
3097  break;
3098 
3099  }
3101  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3102  unsigned int total_size0=H5Tget_size(fieldtype0);
3103  hsize_t fieldlen0;
3104  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3105  hid_t item_type0=H5Tget_super(fieldtype0);
3106  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3107  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3108  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
3109  std::map<std::string, std::vector<double>> x0;
3110  for(unsigned int k0=0;k0<fieldlen0;++k0){
3111  std::string x1key;
3112  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
3113  std::vector<double> x1val;
3114  x1val=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3115  x0[x1key]=x1val;
3116 
3117  }
3118  is_row_selected=CmpConds<std::map<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
3119  if(is_row_selected){
3120  row[j]=x0;
3121 
3122  }
3123  H5Tclose(fieldtype1key);
3124  H5Tclose(item_type0);
3125  H5Tclose(fieldtype0);
3126  break;
3127 
3128  }
3130  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3131  std::map<std::string, std::vector<double>> x0;
3132  x0=VLRead<std::map<std::string, std::vector<double>>,VL_MAP_STRING_VL_VECTOR_DOUBLE>(buf+offset);
3133  is_row_selected=CmpConds<std::map<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
3134  if(is_row_selected){
3135  row[j]=x0;
3136 
3137  }
3138  break;
3139 
3140  }
3142  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3143  std::map<std::string, std::vector<double>> x0;
3144  x0=VLRead<std::map<std::string, std::vector<double>>,VL_MAP_VL_STRING_VECTOR_DOUBLE>(buf+offset);
3145  is_row_selected=CmpConds<std::map<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
3146  if(is_row_selected){
3147  row[j]=x0;
3148 
3149  }
3150  break;
3151 
3152  }
3154  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3155  std::map<std::string, std::vector<double>> x0;
3156  x0=VLRead<std::map<std::string, std::vector<double>>,VL_MAP_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset);
3157  is_row_selected=CmpConds<std::map<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
3158  if(is_row_selected){
3159  row[j]=x0;
3160 
3161  }
3162  break;
3163 
3164  }
3166  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3167  unsigned int total_size0=H5Tget_size(fieldtype0);
3168  hsize_t fieldlen0;
3169  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3170  hid_t item_type0=H5Tget_super(fieldtype0);
3171  size_t nullpos1key;
3172  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3173  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3174  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3175  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3176  hsize_t fieldlen1val;
3177  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
3178  hid_t item_type1val=H5Tget_super(fieldtype1val);
3179  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
3180  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
3181  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
3182  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
3183  std::map<std::string, std::map<int, double>> x0;
3184  for(unsigned int k0=0;k0<fieldlen0;++k0){
3185  std::string x1key;
3186  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
3187  nullpos1key=x1key.find('\0');
3188  if(nullpos1key!=std::string::npos){
3189  x1key.resize(nullpos1key);
3190 
3191  }
3192  std::map<int, double> x1val;
3193  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
3194  int x2valkey;
3195  x2valkey=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val);
3196  double x2valval;
3197  x2valval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
3198  x1val[x2valkey]=x2valval;
3199 
3200  }
3201  x0[x1key]=x1val;
3202 
3203  }
3204  is_row_selected=CmpConds<std::map<std::string, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
3205  if(is_row_selected){
3206  row[j]=x0;
3207 
3208  }
3209  H5Tclose(fieldtype2valval);
3210  H5Tclose(fieldtype2valkey);
3211  H5Tclose(item_type1val);
3212  H5Tclose(fieldtype1val);
3213  H5Tclose(fieldtype1key);
3214  H5Tclose(item_type0);
3215  H5Tclose(fieldtype0);
3216  break;
3217 
3218  }
3220  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3221  unsigned int total_size0=H5Tget_size(fieldtype0);
3222  hsize_t fieldlen0;
3223  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3224  hid_t item_type0=H5Tget_super(fieldtype0);
3225  size_t nullpos1key;
3226  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3227  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3228  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
3229  std::map<std::string, std::map<int, double>> x0;
3230  for(unsigned int k0=0;k0<fieldlen0;++k0){
3231  std::string x1key;
3232  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
3233  nullpos1key=x1key.find('\0');
3234  if(nullpos1key!=std::string::npos){
3235  x1key.resize(nullpos1key);
3236 
3237  }
3238  std::map<int, double> x1val;
3239  x1val=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3240  x0[x1key]=x1val;
3241 
3242  }
3243  is_row_selected=CmpConds<std::map<std::string, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
3244  if(is_row_selected){
3245  row[j]=x0;
3246 
3247  }
3248  H5Tclose(fieldtype1key);
3249  H5Tclose(item_type0);
3250  H5Tclose(fieldtype0);
3251  break;
3252 
3253  }
3255  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3256  std::map<std::string, std::map<int, double>> x0;
3257  x0=VLRead<std::map<std::string, std::map<int, double>>,VL_MAP_STRING_MAP_INT_DOUBLE>(buf+offset);
3258  is_row_selected=CmpConds<std::map<std::string, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
3259  if(is_row_selected){
3260  row[j]=x0;
3261 
3262  }
3263  break;
3264 
3265  }
3267  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3268  unsigned int total_size0=H5Tget_size(fieldtype0);
3269  hsize_t fieldlen0;
3270  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3271  hid_t item_type0=H5Tget_super(fieldtype0);
3272  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3273  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3274  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3275  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3276  hsize_t fieldlen1val;
3277  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
3278  hid_t item_type1val=H5Tget_super(fieldtype1val);
3279  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
3280  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
3281  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
3282  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
3283  std::map<std::string, std::map<int, double>> x0;
3284  for(unsigned int k0=0;k0<fieldlen0;++k0){
3285  std::string x1key;
3286  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
3287  std::map<int, double> x1val;
3288  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
3289  int x2valkey;
3290  x2valkey=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val);
3291  double x2valval;
3292  x2valval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
3293  x1val[x2valkey]=x2valval;
3294 
3295  }
3296  x0[x1key]=x1val;
3297 
3298  }
3299  is_row_selected=CmpConds<std::map<std::string, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
3300  if(is_row_selected){
3301  row[j]=x0;
3302 
3303  }
3304  H5Tclose(fieldtype2valval);
3305  H5Tclose(fieldtype2valkey);
3306  H5Tclose(item_type1val);
3307  H5Tclose(fieldtype1val);
3308  H5Tclose(fieldtype1key);
3309  H5Tclose(item_type0);
3310  H5Tclose(fieldtype0);
3311  break;
3312 
3313  }
3315  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3316  unsigned int total_size0=H5Tget_size(fieldtype0);
3317  hsize_t fieldlen0;
3318  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3319  hid_t item_type0=H5Tget_super(fieldtype0);
3320  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3321  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3322  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
3323  std::map<std::string, std::map<int, double>> x0;
3324  for(unsigned int k0=0;k0<fieldlen0;++k0){
3325  std::string x1key;
3326  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
3327  std::map<int, double> x1val;
3328  x1val=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3329  x0[x1key]=x1val;
3330 
3331  }
3332  is_row_selected=CmpConds<std::map<std::string, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
3333  if(is_row_selected){
3334  row[j]=x0;
3335 
3336  }
3337  H5Tclose(fieldtype1key);
3338  H5Tclose(item_type0);
3339  H5Tclose(fieldtype0);
3340  break;
3341 
3342  }
3344  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3345  std::map<std::string, std::map<int, double>> x0;
3346  x0=VLRead<std::map<std::string, std::map<int, double>>,VL_MAP_STRING_VL_MAP_INT_DOUBLE>(buf+offset);
3347  is_row_selected=CmpConds<std::map<std::string, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
3348  if(is_row_selected){
3349  row[j]=x0;
3350 
3351  }
3352  break;
3353 
3354  }
3356  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3357  std::map<std::string, std::map<int, double>> x0;
3358  x0=VLRead<std::map<std::string, std::map<int, double>>,VL_MAP_VL_STRING_MAP_INT_DOUBLE>(buf+offset);
3359  is_row_selected=CmpConds<std::map<std::string, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
3360  if(is_row_selected){
3361  row[j]=x0;
3362 
3363  }
3364  break;
3365 
3366  }
3368  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3369  std::map<std::string, std::map<int, double>> x0;
3370  x0=VLRead<std::map<std::string, std::map<int, double>>,VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE>(buf+offset);
3371  is_row_selected=CmpConds<std::map<std::string, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
3372  if(is_row_selected){
3373  row[j]=x0;
3374 
3375  }
3376  break;
3377 
3378  }
3380  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3381  unsigned int total_size0=H5Tget_size(fieldtype0);
3382  hsize_t fieldlen0;
3383  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3384  hid_t item_type0=H5Tget_super(fieldtype0);
3385  size_t nullpos1key;
3386  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3387  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3388  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3389  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3390  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
3391  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
3392  hid_t fieldtype2valsecond=H5Tget_member_type(fieldtype1val, 1);
3393  unsigned int total_size2valsecond=H5Tget_size(fieldtype2valsecond);
3394  hsize_t fieldlen2valsecond;
3395  H5Tget_array_dims2(fieldtype2valsecond, &fieldlen2valsecond);
3396  hid_t item_type2valsecond=H5Tget_super(fieldtype2valsecond);
3397  hid_t fieldtype3valsecondkey=H5Tget_member_type(item_type2valsecond, 0);
3398  unsigned int total_size3valsecondkey=H5Tget_size(fieldtype3valsecondkey);
3399  hid_t fieldtype3valsecondval=H5Tget_member_type(item_type2valsecond, 1);
3400  unsigned int total_size3valsecondval=H5Tget_size(fieldtype3valsecondval);
3401  std::map<std::string, std::pair<double, std::map<int, double>>> x0;
3402  for(unsigned int k0=0;k0<fieldlen0;++k0){
3403  std::string x1key;
3404  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
3405  nullpos1key=x1key.find('\0');
3406  if(nullpos1key!=std::string::npos){
3407  x1key.resize(nullpos1key);
3408 
3409  }
3410  std::pair<double, std::map<int, double>> x1val;
3411  double x2valfirst;
3412  x2valfirst=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3413  std::map<int, double> x2valsecond;
3414  for(unsigned int k2valsecond=0;k2valsecond<fieldlen2valsecond;++k2valsecond){
3415  int x3valsecondkey;
3416  x3valsecondkey=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst+(total_size3valsecondkey+total_size3valsecondval)*k2valsecond);
3417  double x3valsecondval;
3418  x3valsecondval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst+(total_size3valsecondkey+total_size3valsecondval)*k2valsecond+total_size3valsecondkey);
3419  x2valsecond[x3valsecondkey]=x3valsecondval;
3420 
3421  }
3422  x1val=std::make_pair(x2valfirst, x2valsecond);
3423  x0[x1key]=x1val;
3424 
3425  }
3426  is_row_selected=CmpConds<std::map<std::string, std::pair<double, std::map<int, double>>>>(&x0, &(field_conds[qr.fields[j]]));
3427  if(is_row_selected){
3428  row[j]=x0;
3429 
3430  }
3431  H5Tclose(fieldtype3valsecondval);
3432  H5Tclose(fieldtype3valsecondkey);
3433  H5Tclose(item_type2valsecond);
3434  H5Tclose(fieldtype2valsecond);
3435  H5Tclose(fieldtype2valfirst);
3436  H5Tclose(fieldtype1val);
3437  H5Tclose(fieldtype1key);
3438  H5Tclose(item_type0);
3439  H5Tclose(fieldtype0);
3440  break;
3441 
3442  }
3444  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3445  std::map<std::string, std::pair<double, std::map<int, double>>> x0;
3446  x0=VLRead<std::map<std::string, std::pair<double, std::map<int, double>>>,VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset);
3447  is_row_selected=CmpConds<std::map<std::string, std::pair<double, std::map<int, double>>>>(&x0, &(field_conds[qr.fields[j]]));
3448  if(is_row_selected){
3449  row[j]=x0;
3450 
3451  }
3452  break;
3453 
3454  }
3456  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3457  unsigned int total_size0=H5Tget_size(fieldtype0);
3458  hsize_t fieldlen0;
3459  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3460  hid_t item_type0=H5Tget_super(fieldtype0);
3461  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3462  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3463  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3464  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3465  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
3466  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
3467  hid_t fieldtype2valsecond=H5Tget_member_type(fieldtype1val, 1);
3468  unsigned int total_size2valsecond=H5Tget_size(fieldtype2valsecond);
3469  hsize_t fieldlen2valsecond;
3470  H5Tget_array_dims2(fieldtype2valsecond, &fieldlen2valsecond);
3471  hid_t item_type2valsecond=H5Tget_super(fieldtype2valsecond);
3472  hid_t fieldtype3valsecondkey=H5Tget_member_type(item_type2valsecond, 0);
3473  unsigned int total_size3valsecondkey=H5Tget_size(fieldtype3valsecondkey);
3474  hid_t fieldtype3valsecondval=H5Tget_member_type(item_type2valsecond, 1);
3475  unsigned int total_size3valsecondval=H5Tget_size(fieldtype3valsecondval);
3476  std::map<std::string, std::pair<double, std::map<int, double>>> x0;
3477  for(unsigned int k0=0;k0<fieldlen0;++k0){
3478  std::string x1key;
3479  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
3480  std::pair<double, std::map<int, double>> x1val;
3481  double x2valfirst;
3482  x2valfirst=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3483  std::map<int, double> x2valsecond;
3484  for(unsigned int k2valsecond=0;k2valsecond<fieldlen2valsecond;++k2valsecond){
3485  int x3valsecondkey;
3486  x3valsecondkey=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst+(total_size3valsecondkey+total_size3valsecondval)*k2valsecond);
3487  double x3valsecondval;
3488  x3valsecondval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst+(total_size3valsecondkey+total_size3valsecondval)*k2valsecond+total_size3valsecondkey);
3489  x2valsecond[x3valsecondkey]=x3valsecondval;
3490 
3491  }
3492  x1val=std::make_pair(x2valfirst, x2valsecond);
3493  x0[x1key]=x1val;
3494 
3495  }
3496  is_row_selected=CmpConds<std::map<std::string, std::pair<double, std::map<int, double>>>>(&x0, &(field_conds[qr.fields[j]]));
3497  if(is_row_selected){
3498  row[j]=x0;
3499 
3500  }
3501  H5Tclose(fieldtype3valsecondval);
3502  H5Tclose(fieldtype3valsecondkey);
3503  H5Tclose(item_type2valsecond);
3504  H5Tclose(fieldtype2valsecond);
3505  H5Tclose(fieldtype2valfirst);
3506  H5Tclose(fieldtype1val);
3507  H5Tclose(fieldtype1key);
3508  H5Tclose(item_type0);
3509  H5Tclose(fieldtype0);
3510  break;
3511 
3512  }
3514  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3515  unsigned int total_size0=H5Tget_size(fieldtype0);
3516  hsize_t fieldlen0;
3517  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3518  hid_t item_type0=H5Tget_super(fieldtype0);
3519  size_t nullpos1key;
3520  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3521  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3522  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3523  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3524  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
3525  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
3526  unsigned int total_size2valsecond=CYCLUS_SHA1_SIZE;
3527  std::map<std::string, std::pair<double, std::map<int, double>>> x0;
3528  for(unsigned int k0=0;k0<fieldlen0;++k0){
3529  std::string x1key;
3530  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
3531  nullpos1key=x1key.find('\0');
3532  if(nullpos1key!=std::string::npos){
3533  x1key.resize(nullpos1key);
3534 
3535  }
3536  std::pair<double, std::map<int, double>> x1val;
3537  double x2valfirst;
3538  x2valfirst=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3539  std::map<int, double> x2valsecond;
3540  x2valsecond=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst);
3541  x1val=std::make_pair(x2valfirst, x2valsecond);
3542  x0[x1key]=x1val;
3543 
3544  }
3545  is_row_selected=CmpConds<std::map<std::string, std::pair<double, std::map<int, double>>>>(&x0, &(field_conds[qr.fields[j]]));
3546  if(is_row_selected){
3547  row[j]=x0;
3548 
3549  }
3550  H5Tclose(fieldtype2valfirst);
3551  H5Tclose(fieldtype1val);
3552  H5Tclose(fieldtype1key);
3553  H5Tclose(item_type0);
3554  H5Tclose(fieldtype0);
3555  break;
3556 
3557  }
3559  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3560  std::map<std::string, std::pair<double, std::map<int, double>>> x0;
3561  x0=VLRead<std::map<std::string, std::pair<double, std::map<int, double>>>,VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset);
3562  is_row_selected=CmpConds<std::map<std::string, std::pair<double, std::map<int, double>>>>(&x0, &(field_conds[qr.fields[j]]));
3563  if(is_row_selected){
3564  row[j]=x0;
3565 
3566  }
3567  break;
3568 
3569  }
3571  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3572  std::map<std::string, std::pair<double, std::map<int, double>>> x0;
3573  x0=VLRead<std::map<std::string, std::pair<double, std::map<int, double>>>,VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset);
3574  is_row_selected=CmpConds<std::map<std::string, std::pair<double, std::map<int, double>>>>(&x0, &(field_conds[qr.fields[j]]));
3575  if(is_row_selected){
3576  row[j]=x0;
3577 
3578  }
3579  break;
3580 
3581  }
3583  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3584  unsigned int total_size0=H5Tget_size(fieldtype0);
3585  hsize_t fieldlen0;
3586  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3587  hid_t item_type0=H5Tget_super(fieldtype0);
3588  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3589  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3590  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3591  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3592  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
3593  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
3594  unsigned int total_size2valsecond=CYCLUS_SHA1_SIZE;
3595  std::map<std::string, std::pair<double, std::map<int, double>>> x0;
3596  for(unsigned int k0=0;k0<fieldlen0;++k0){
3597  std::string x1key;
3598  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
3599  std::pair<double, std::map<int, double>> x1val;
3600  double x2valfirst;
3601  x2valfirst=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3602  std::map<int, double> x2valsecond;
3603  x2valsecond=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst);
3604  x1val=std::make_pair(x2valfirst, x2valsecond);
3605  x0[x1key]=x1val;
3606 
3607  }
3608  is_row_selected=CmpConds<std::map<std::string, std::pair<double, std::map<int, double>>>>(&x0, &(field_conds[qr.fields[j]]));
3609  if(is_row_selected){
3610  row[j]=x0;
3611 
3612  }
3613  H5Tclose(fieldtype2valfirst);
3614  H5Tclose(fieldtype1val);
3615  H5Tclose(fieldtype1key);
3616  H5Tclose(item_type0);
3617  H5Tclose(fieldtype0);
3618  break;
3619 
3620  }
3622  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3623  std::map<std::string, std::pair<double, std::map<int, double>>> x0;
3624  x0=VLRead<std::map<std::string, std::pair<double, std::map<int, double>>>,VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset);
3625  is_row_selected=CmpConds<std::map<std::string, std::pair<double, std::map<int, double>>>>(&x0, &(field_conds[qr.fields[j]]));
3626  if(is_row_selected){
3627  row[j]=x0;
3628 
3629  }
3630  break;
3631 
3632  }
3634  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3635  unsigned int total_size0=H5Tget_size(fieldtype0);
3636  hsize_t fieldlen0;
3637  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3638  hid_t item_type0=H5Tget_super(fieldtype0);
3639  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3640  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3641  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3642  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3643  hsize_t fieldlen1val;
3644  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
3645  hid_t item_type1val=H5Tget_super(fieldtype1val);
3646  size_t nullpos2valkey;
3647  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
3648  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
3649  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
3650  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
3651  std::map<int, std::map<std::string, double>> x0;
3652  for(unsigned int k0=0;k0<fieldlen0;++k0){
3653  int x1key;
3654  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
3655  std::map<std::string, double> x1val;
3656  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
3657  std::string x2valkey;
3658  x2valkey=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val, total_size2valkey);
3659  nullpos2valkey=x2valkey.find('\0');
3660  if(nullpos2valkey!=std::string::npos){
3661  x2valkey.resize(nullpos2valkey);
3662 
3663  }
3664  double x2valval;
3665  x2valval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
3666  x1val[x2valkey]=x2valval;
3667 
3668  }
3669  x0[x1key]=x1val;
3670 
3671  }
3672  is_row_selected=CmpConds<std::map<int, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
3673  if(is_row_selected){
3674  row[j]=x0;
3675 
3676  }
3677  H5Tclose(fieldtype2valval);
3678  H5Tclose(fieldtype2valkey);
3679  H5Tclose(item_type1val);
3680  H5Tclose(fieldtype1val);
3681  H5Tclose(fieldtype1key);
3682  H5Tclose(item_type0);
3683  H5Tclose(fieldtype0);
3684  break;
3685 
3686  }
3688  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3689  unsigned int total_size0=H5Tget_size(fieldtype0);
3690  hsize_t fieldlen0;
3691  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3692  hid_t item_type0=H5Tget_super(fieldtype0);
3693  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3694  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3695  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3696  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3697  hsize_t fieldlen1val;
3698  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
3699  hid_t item_type1val=H5Tget_super(fieldtype1val);
3700  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
3701  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
3702  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
3703  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
3704  std::map<int, std::map<std::string, double>> x0;
3705  for(unsigned int k0=0;k0<fieldlen0;++k0){
3706  int x1key;
3707  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
3708  std::map<std::string, double> x1val;
3709  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
3710  std::string x2valkey;
3711  x2valkey=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val);
3712  double x2valval;
3713  x2valval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
3714  x1val[x2valkey]=x2valval;
3715 
3716  }
3717  x0[x1key]=x1val;
3718 
3719  }
3720  is_row_selected=CmpConds<std::map<int, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
3721  if(is_row_selected){
3722  row[j]=x0;
3723 
3724  }
3725  H5Tclose(fieldtype2valval);
3726  H5Tclose(fieldtype2valkey);
3727  H5Tclose(item_type1val);
3728  H5Tclose(fieldtype1val);
3729  H5Tclose(fieldtype1key);
3730  H5Tclose(item_type0);
3731  H5Tclose(fieldtype0);
3732  break;
3733 
3734  }
3736  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3737  std::map<int, std::map<std::string, double>> x0;
3738  x0=VLRead<std::map<int, std::map<std::string, double>>,VL_MAP_INT_MAP_STRING_DOUBLE>(buf+offset);
3739  is_row_selected=CmpConds<std::map<int, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
3740  if(is_row_selected){
3741  row[j]=x0;
3742 
3743  }
3744  break;
3745 
3746  }
3748  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3749  std::map<int, std::map<std::string, double>> x0;
3750  x0=VLRead<std::map<int, std::map<std::string, double>>,VL_MAP_INT_MAP_VL_STRING_DOUBLE>(buf+offset);
3751  is_row_selected=CmpConds<std::map<int, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
3752  if(is_row_selected){
3753  row[j]=x0;
3754 
3755  }
3756  break;
3757 
3758  }
3760  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3761  unsigned int total_size0=H5Tget_size(fieldtype0);
3762  hsize_t fieldlen0;
3763  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3764  hid_t item_type0=H5Tget_super(fieldtype0);
3765  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3766  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3767  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
3768  std::map<int, std::map<std::string, double>> x0;
3769  for(unsigned int k0=0;k0<fieldlen0;++k0){
3770  int x1key;
3771  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
3772  std::map<std::string, double> x1val;
3773  x1val=VLRead<std::map<std::string, double>,VL_MAP_STRING_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3774  x0[x1key]=x1val;
3775 
3776  }
3777  is_row_selected=CmpConds<std::map<int, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
3778  if(is_row_selected){
3779  row[j]=x0;
3780 
3781  }
3782  H5Tclose(fieldtype1key);
3783  H5Tclose(item_type0);
3784  H5Tclose(fieldtype0);
3785  break;
3786 
3787  }
3789  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3790  unsigned int total_size0=H5Tget_size(fieldtype0);
3791  hsize_t fieldlen0;
3792  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3793  hid_t item_type0=H5Tget_super(fieldtype0);
3794  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3795  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3796  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
3797  std::map<int, std::map<std::string, double>> x0;
3798  for(unsigned int k0=0;k0<fieldlen0;++k0){
3799  int x1key;
3800  x1key=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0);
3801  std::map<std::string, double> x1val;
3802  x1val=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
3803  x0[x1key]=x1val;
3804 
3805  }
3806  is_row_selected=CmpConds<std::map<int, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
3807  if(is_row_selected){
3808  row[j]=x0;
3809 
3810  }
3811  H5Tclose(fieldtype1key);
3812  H5Tclose(item_type0);
3813  H5Tclose(fieldtype0);
3814  break;
3815 
3816  }
3818  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3819  std::map<int, std::map<std::string, double>> x0;
3820  x0=VLRead<std::map<int, std::map<std::string, double>>,VL_MAP_INT_VL_MAP_STRING_DOUBLE>(buf+offset);
3821  is_row_selected=CmpConds<std::map<int, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
3822  if(is_row_selected){
3823  row[j]=x0;
3824 
3825  }
3826  break;
3827 
3828  }
3830  unsigned int total_size0=CYCLUS_SHA1_SIZE;
3831  std::map<int, std::map<std::string, double>> x0;
3832  x0=VLRead<std::map<int, std::map<std::string, double>>,VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE>(buf+offset);
3833  is_row_selected=CmpConds<std::map<int, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
3834  if(is_row_selected){
3835  row[j]=x0;
3836 
3837  }
3838  break;
3839 
3840  }
3842  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3843  unsigned int total_size0=H5Tget_size(fieldtype0);
3844  hsize_t fieldlen0;
3845  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3846  hid_t item_type0=H5Tget_super(fieldtype0);
3847  size_t nullpos1key;
3848  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3849  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3850  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3851  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3852  hsize_t fieldlen1val;
3853  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
3854  hid_t item_type1val=H5Tget_super(fieldtype1val);
3855  unsigned int total_size2valelem=H5Tget_size(item_type1val);
3856  hid_t fieldtype3valelemfirst=H5Tget_member_type(item_type1val, 0);
3857  unsigned int total_size3valelemfirst=H5Tget_size(fieldtype3valelemfirst);
3858  hid_t fieldtype3valelemsecond=H5Tget_member_type(item_type1val, 1);
3859  unsigned int total_size3valelemsecond=H5Tget_size(fieldtype3valelemsecond);
3860  size_t nullpos4valelemsecondfirst;
3861  hid_t fieldtype4valelemsecondfirst=H5Tget_member_type(fieldtype3valelemsecond, 0);
3862  unsigned int total_size4valelemsecondfirst=H5Tget_size(fieldtype4valelemsecondfirst);
3863  size_t nullpos4valelemsecondsecond;
3864  hid_t fieldtype4valelemsecondsecond=H5Tget_member_type(fieldtype3valelemsecond, 1);
3865  unsigned int total_size4valelemsecondsecond=H5Tget_size(fieldtype4valelemsecondsecond);
3866  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
3867  for(unsigned int k0=0;k0<fieldlen0;++k0){
3868  std::string x1key;
3869  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
3870  nullpos1key=x1key.find('\0');
3871  if(nullpos1key!=std::string::npos){
3872  x1key.resize(nullpos1key);
3873 
3874  }
3875  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
3876  x1val=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen1val);
3877  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
3878  std::pair<int, std::pair<std::string, std::string>> x2valelem;
3879  int x3valelemfirst;
3880  x3valelemfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val);
3881  std::pair<std::string, std::string> x3valelemsecond;
3882  std::string x4valelemsecondfirst;
3883  x4valelemsecondfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst, total_size4valelemsecondfirst);
3884  nullpos4valelemsecondfirst=x4valelemsecondfirst.find('\0');
3885  if(nullpos4valelemsecondfirst!=std::string::npos){
3886  x4valelemsecondfirst.resize(nullpos4valelemsecondfirst);
3887 
3888  }
3889  std::string x4valelemsecondsecond;
3890  x4valelemsecondsecond=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst+total_size4valelemsecondfirst, total_size4valelemsecondsecond);
3891  nullpos4valelemsecondsecond=x4valelemsecondsecond.find('\0');
3892  if(nullpos4valelemsecondsecond!=std::string::npos){
3893  x4valelemsecondsecond.resize(nullpos4valelemsecondsecond);
3894 
3895  }
3896  x3valelemsecond=std::make_pair(x4valelemsecondfirst, x4valelemsecondsecond);
3897  x2valelem=std::make_pair(x3valelemfirst, x3valelemsecond);
3898  x1val[k1val]=x2valelem;
3899 
3900  }
3901  x0[x1key]=x1val;
3902 
3903  }
3904  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
3905  if(is_row_selected){
3906  row[j]=x0;
3907 
3908  }
3909  H5Tclose(fieldtype4valelemsecondsecond);
3910  H5Tclose(fieldtype4valelemsecondfirst);
3911  H5Tclose(fieldtype3valelemsecond);
3912  H5Tclose(fieldtype3valelemfirst);
3913  H5Tclose(item_type1val);
3914  H5Tclose(fieldtype1val);
3915  H5Tclose(fieldtype1key);
3916  H5Tclose(item_type0);
3917  H5Tclose(fieldtype0);
3918  break;
3919 
3920  }
3922  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3923  unsigned int total_size0=H5Tget_size(fieldtype0);
3924  hsize_t fieldlen0;
3925  H5Tget_array_dims2(fieldtype0, &fieldlen0);
3926  hid_t item_type0=H5Tget_super(fieldtype0);
3927  size_t nullpos1key;
3928  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
3929  unsigned int total_size1key=H5Tget_size(fieldtype1key);
3930  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
3931  unsigned int total_size1val=H5Tget_size(fieldtype1val);
3932  hsize_t fieldlen1val;
3933  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
3934  hid_t item_type1val=H5Tget_super(fieldtype1val);
3935  unsigned int total_size2valelem=H5Tget_size(item_type1val);
3936  hid_t fieldtype3valelemfirst=H5Tget_member_type(item_type1val, 0);
3937  unsigned int total_size3valelemfirst=H5Tget_size(fieldtype3valelemfirst);
3938  hid_t fieldtype3valelemsecond=H5Tget_member_type(item_type1val, 1);
3939  unsigned int total_size3valelemsecond=H5Tget_size(fieldtype3valelemsecond);
3940  size_t nullpos4valelemsecondfirst;
3941  hid_t fieldtype4valelemsecondfirst=H5Tget_member_type(fieldtype3valelemsecond, 0);
3942  unsigned int total_size4valelemsecondfirst=H5Tget_size(fieldtype4valelemsecondfirst);
3943  hid_t fieldtype4valelemsecondsecond=H5Tget_member_type(fieldtype3valelemsecond, 1);
3944  unsigned int total_size4valelemsecondsecond=H5Tget_size(fieldtype4valelemsecondsecond);
3945  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
3946  for(unsigned int k0=0;k0<fieldlen0;++k0){
3947  std::string x1key;
3948  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
3949  nullpos1key=x1key.find('\0');
3950  if(nullpos1key!=std::string::npos){
3951  x1key.resize(nullpos1key);
3952 
3953  }
3954  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
3955  x1val=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen1val);
3956  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
3957  std::pair<int, std::pair<std::string, std::string>> x2valelem;
3958  int x3valelemfirst;
3959  x3valelemfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val);
3960  std::pair<std::string, std::string> x3valelemsecond;
3961  std::string x4valelemsecondfirst;
3962  x4valelemsecondfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst, total_size4valelemsecondfirst);
3963  nullpos4valelemsecondfirst=x4valelemsecondfirst.find('\0');
3964  if(nullpos4valelemsecondfirst!=std::string::npos){
3965  x4valelemsecondfirst.resize(nullpos4valelemsecondfirst);
3966 
3967  }
3968  std::string x4valelemsecondsecond;
3969  x4valelemsecondsecond=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst+total_size4valelemsecondfirst);
3970  x3valelemsecond=std::make_pair(x4valelemsecondfirst, x4valelemsecondsecond);
3971  x2valelem=std::make_pair(x3valelemfirst, x3valelemsecond);
3972  x1val[k1val]=x2valelem;
3973 
3974  }
3975  x0[x1key]=x1val;
3976 
3977  }
3978  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
3979  if(is_row_selected){
3980  row[j]=x0;
3981 
3982  }
3983  H5Tclose(fieldtype4valelemsecondsecond);
3984  H5Tclose(fieldtype4valelemsecondfirst);
3985  H5Tclose(fieldtype3valelemsecond);
3986  H5Tclose(fieldtype3valelemfirst);
3987  H5Tclose(item_type1val);
3988  H5Tclose(fieldtype1val);
3989  H5Tclose(fieldtype1key);
3990  H5Tclose(item_type0);
3991  H5Tclose(fieldtype0);
3992  break;
3993 
3994  }
3996  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
3997  unsigned int total_size0=H5Tget_size(fieldtype0);
3998  hsize_t fieldlen0;
3999  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4000  hid_t item_type0=H5Tget_super(fieldtype0);
4001  size_t nullpos1key;
4002  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4003  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4004  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
4005  unsigned int total_size1val=H5Tget_size(fieldtype1val);
4006  hsize_t fieldlen1val;
4007  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
4008  hid_t item_type1val=H5Tget_super(fieldtype1val);
4009  unsigned int total_size2valelem=H5Tget_size(item_type1val);
4010  hid_t fieldtype3valelemfirst=H5Tget_member_type(item_type1val, 0);
4011  unsigned int total_size3valelemfirst=H5Tget_size(fieldtype3valelemfirst);
4012  hid_t fieldtype3valelemsecond=H5Tget_member_type(item_type1val, 1);
4013  unsigned int total_size3valelemsecond=H5Tget_size(fieldtype3valelemsecond);
4014  hid_t fieldtype4valelemsecondfirst=H5Tget_member_type(fieldtype3valelemsecond, 0);
4015  unsigned int total_size4valelemsecondfirst=H5Tget_size(fieldtype4valelemsecondfirst);
4016  size_t nullpos4valelemsecondsecond;
4017  hid_t fieldtype4valelemsecondsecond=H5Tget_member_type(fieldtype3valelemsecond, 1);
4018  unsigned int total_size4valelemsecondsecond=H5Tget_size(fieldtype4valelemsecondsecond);
4019  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4020  for(unsigned int k0=0;k0<fieldlen0;++k0){
4021  std::string x1key;
4022  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
4023  nullpos1key=x1key.find('\0');
4024  if(nullpos1key!=std::string::npos){
4025  x1key.resize(nullpos1key);
4026 
4027  }
4028  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4029  x1val=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen1val);
4030  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
4031  std::pair<int, std::pair<std::string, std::string>> x2valelem;
4032  int x3valelemfirst;
4033  x3valelemfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val);
4034  std::pair<std::string, std::string> x3valelemsecond;
4035  std::string x4valelemsecondfirst;
4036  x4valelemsecondfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst);
4037  std::string x4valelemsecondsecond;
4038  x4valelemsecondsecond=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst+total_size4valelemsecondfirst, total_size4valelemsecondsecond);
4039  nullpos4valelemsecondsecond=x4valelemsecondsecond.find('\0');
4040  if(nullpos4valelemsecondsecond!=std::string::npos){
4041  x4valelemsecondsecond.resize(nullpos4valelemsecondsecond);
4042 
4043  }
4044  x3valelemsecond=std::make_pair(x4valelemsecondfirst, x4valelemsecondsecond);
4045  x2valelem=std::make_pair(x3valelemfirst, x3valelemsecond);
4046  x1val[k1val]=x2valelem;
4047 
4048  }
4049  x0[x1key]=x1val;
4050 
4051  }
4052  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4053  if(is_row_selected){
4054  row[j]=x0;
4055 
4056  }
4057  H5Tclose(fieldtype4valelemsecondsecond);
4058  H5Tclose(fieldtype4valelemsecondfirst);
4059  H5Tclose(fieldtype3valelemsecond);
4060  H5Tclose(fieldtype3valelemfirst);
4061  H5Tclose(item_type1val);
4062  H5Tclose(fieldtype1val);
4063  H5Tclose(fieldtype1key);
4064  H5Tclose(item_type0);
4065  H5Tclose(fieldtype0);
4066  break;
4067 
4068  }
4070  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4071  unsigned int total_size0=H5Tget_size(fieldtype0);
4072  hsize_t fieldlen0;
4073  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4074  hid_t item_type0=H5Tget_super(fieldtype0);
4075  size_t nullpos1key;
4076  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4077  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4078  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
4079  unsigned int total_size1val=H5Tget_size(fieldtype1val);
4080  hsize_t fieldlen1val;
4081  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
4082  hid_t item_type1val=H5Tget_super(fieldtype1val);
4083  unsigned int total_size2valelem=H5Tget_size(item_type1val);
4084  hid_t fieldtype3valelemfirst=H5Tget_member_type(item_type1val, 0);
4085  unsigned int total_size3valelemfirst=H5Tget_size(fieldtype3valelemfirst);
4086  hid_t fieldtype3valelemsecond=H5Tget_member_type(item_type1val, 1);
4087  unsigned int total_size3valelemsecond=H5Tget_size(fieldtype3valelemsecond);
4088  hid_t fieldtype4valelemsecondfirst=H5Tget_member_type(fieldtype3valelemsecond, 0);
4089  unsigned int total_size4valelemsecondfirst=H5Tget_size(fieldtype4valelemsecondfirst);
4090  hid_t fieldtype4valelemsecondsecond=H5Tget_member_type(fieldtype3valelemsecond, 1);
4091  unsigned int total_size4valelemsecondsecond=H5Tget_size(fieldtype4valelemsecondsecond);
4092  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4093  for(unsigned int k0=0;k0<fieldlen0;++k0){
4094  std::string x1key;
4095  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
4096  nullpos1key=x1key.find('\0');
4097  if(nullpos1key!=std::string::npos){
4098  x1key.resize(nullpos1key);
4099 
4100  }
4101  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4102  x1val=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen1val);
4103  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
4104  std::pair<int, std::pair<std::string, std::string>> x2valelem;
4105  int x3valelemfirst;
4106  x3valelemfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val);
4107  std::pair<std::string, std::string> x3valelemsecond;
4108  std::string x4valelemsecondfirst;
4109  x4valelemsecondfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst);
4110  std::string x4valelemsecondsecond;
4111  x4valelemsecondsecond=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst+total_size4valelemsecondfirst);
4112  x3valelemsecond=std::make_pair(x4valelemsecondfirst, x4valelemsecondsecond);
4113  x2valelem=std::make_pair(x3valelemfirst, x3valelemsecond);
4114  x1val[k1val]=x2valelem;
4115 
4116  }
4117  x0[x1key]=x1val;
4118 
4119  }
4120  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4121  if(is_row_selected){
4122  row[j]=x0;
4123 
4124  }
4125  H5Tclose(fieldtype4valelemsecondsecond);
4126  H5Tclose(fieldtype4valelemsecondfirst);
4127  H5Tclose(fieldtype3valelemsecond);
4128  H5Tclose(fieldtype3valelemfirst);
4129  H5Tclose(item_type1val);
4130  H5Tclose(fieldtype1val);
4131  H5Tclose(fieldtype1key);
4132  H5Tclose(item_type0);
4133  H5Tclose(fieldtype0);
4134  break;
4135 
4136  }
4138  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4139  unsigned int total_size0=H5Tget_size(fieldtype0);
4140  hsize_t fieldlen0;
4141  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4142  hid_t item_type0=H5Tget_super(fieldtype0);
4143  size_t nullpos1key;
4144  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4145  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4146  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
4147  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4148  for(unsigned int k0=0;k0<fieldlen0;++k0){
4149  std::string x1key;
4150  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
4151  nullpos1key=x1key.find('\0');
4152  if(nullpos1key!=std::string::npos){
4153  x1key.resize(nullpos1key);
4154 
4155  }
4156  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4157  x1val=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
4158  x0[x1key]=x1val;
4159 
4160  }
4161  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4162  if(is_row_selected){
4163  row[j]=x0;
4164 
4165  }
4166  H5Tclose(fieldtype1key);
4167  H5Tclose(item_type0);
4168  H5Tclose(fieldtype0);
4169  break;
4170 
4171  }
4173  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4174  unsigned int total_size0=H5Tget_size(fieldtype0);
4175  hsize_t fieldlen0;
4176  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4177  hid_t item_type0=H5Tget_super(fieldtype0);
4178  size_t nullpos1key;
4179  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4180  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4181  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
4182  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4183  for(unsigned int k0=0;k0<fieldlen0;++k0){
4184  std::string x1key;
4185  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
4186  nullpos1key=x1key.find('\0');
4187  if(nullpos1key!=std::string::npos){
4188  x1key.resize(nullpos1key);
4189 
4190  }
4191  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4192  x1val=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
4193  x0[x1key]=x1val;
4194 
4195  }
4196  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4197  if(is_row_selected){
4198  row[j]=x0;
4199 
4200  }
4201  H5Tclose(fieldtype1key);
4202  H5Tclose(item_type0);
4203  H5Tclose(fieldtype0);
4204  break;
4205 
4206  }
4208  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4209  unsigned int total_size0=H5Tget_size(fieldtype0);
4210  hsize_t fieldlen0;
4211  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4212  hid_t item_type0=H5Tget_super(fieldtype0);
4213  size_t nullpos1key;
4214  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4215  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4216  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
4217  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4218  for(unsigned int k0=0;k0<fieldlen0;++k0){
4219  std::string x1key;
4220  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
4221  nullpos1key=x1key.find('\0');
4222  if(nullpos1key!=std::string::npos){
4223  x1key.resize(nullpos1key);
4224 
4225  }
4226  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4227  x1val=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
4228  x0[x1key]=x1val;
4229 
4230  }
4231  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4232  if(is_row_selected){
4233  row[j]=x0;
4234 
4235  }
4236  H5Tclose(fieldtype1key);
4237  H5Tclose(item_type0);
4238  H5Tclose(fieldtype0);
4239  break;
4240 
4241  }
4243  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4244  unsigned int total_size0=H5Tget_size(fieldtype0);
4245  hsize_t fieldlen0;
4246  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4247  hid_t item_type0=H5Tget_super(fieldtype0);
4248  size_t nullpos1key;
4249  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4250  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4251  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
4252  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4253  for(unsigned int k0=0;k0<fieldlen0;++k0){
4254  std::string x1key;
4255  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
4256  nullpos1key=x1key.find('\0');
4257  if(nullpos1key!=std::string::npos){
4258  x1key.resize(nullpos1key);
4259 
4260  }
4261  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4262  x1val=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
4263  x0[x1key]=x1val;
4264 
4265  }
4266  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4267  if(is_row_selected){
4268  row[j]=x0;
4269 
4270  }
4271  H5Tclose(fieldtype1key);
4272  H5Tclose(item_type0);
4273  H5Tclose(fieldtype0);
4274  break;
4275 
4276  }
4278  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4279  unsigned int total_size0=H5Tget_size(fieldtype0);
4280  hsize_t fieldlen0;
4281  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4282  hid_t item_type0=H5Tget_super(fieldtype0);
4283  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4284  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4285  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
4286  unsigned int total_size1val=H5Tget_size(fieldtype1val);
4287  hsize_t fieldlen1val;
4288  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
4289  hid_t item_type1val=H5Tget_super(fieldtype1val);
4290  unsigned int total_size2valelem=H5Tget_size(item_type1val);
4291  hid_t fieldtype3valelemfirst=H5Tget_member_type(item_type1val, 0);
4292  unsigned int total_size3valelemfirst=H5Tget_size(fieldtype3valelemfirst);
4293  hid_t fieldtype3valelemsecond=H5Tget_member_type(item_type1val, 1);
4294  unsigned int total_size3valelemsecond=H5Tget_size(fieldtype3valelemsecond);
4295  size_t nullpos4valelemsecondfirst;
4296  hid_t fieldtype4valelemsecondfirst=H5Tget_member_type(fieldtype3valelemsecond, 0);
4297  unsigned int total_size4valelemsecondfirst=H5Tget_size(fieldtype4valelemsecondfirst);
4298  size_t nullpos4valelemsecondsecond;
4299  hid_t fieldtype4valelemsecondsecond=H5Tget_member_type(fieldtype3valelemsecond, 1);
4300  unsigned int total_size4valelemsecondsecond=H5Tget_size(fieldtype4valelemsecondsecond);
4301  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4302  for(unsigned int k0=0;k0<fieldlen0;++k0){
4303  std::string x1key;
4304  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
4305  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4306  x1val=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen1val);
4307  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
4308  std::pair<int, std::pair<std::string, std::string>> x2valelem;
4309  int x3valelemfirst;
4310  x3valelemfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val);
4311  std::pair<std::string, std::string> x3valelemsecond;
4312  std::string x4valelemsecondfirst;
4313  x4valelemsecondfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst, total_size4valelemsecondfirst);
4314  nullpos4valelemsecondfirst=x4valelemsecondfirst.find('\0');
4315  if(nullpos4valelemsecondfirst!=std::string::npos){
4316  x4valelemsecondfirst.resize(nullpos4valelemsecondfirst);
4317 
4318  }
4319  std::string x4valelemsecondsecond;
4320  x4valelemsecondsecond=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst+total_size4valelemsecondfirst, total_size4valelemsecondsecond);
4321  nullpos4valelemsecondsecond=x4valelemsecondsecond.find('\0');
4322  if(nullpos4valelemsecondsecond!=std::string::npos){
4323  x4valelemsecondsecond.resize(nullpos4valelemsecondsecond);
4324 
4325  }
4326  x3valelemsecond=std::make_pair(x4valelemsecondfirst, x4valelemsecondsecond);
4327  x2valelem=std::make_pair(x3valelemfirst, x3valelemsecond);
4328  x1val[k1val]=x2valelem;
4329 
4330  }
4331  x0[x1key]=x1val;
4332 
4333  }
4334  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4335  if(is_row_selected){
4336  row[j]=x0;
4337 
4338  }
4339  H5Tclose(fieldtype4valelemsecondsecond);
4340  H5Tclose(fieldtype4valelemsecondfirst);
4341  H5Tclose(fieldtype3valelemsecond);
4342  H5Tclose(fieldtype3valelemfirst);
4343  H5Tclose(item_type1val);
4344  H5Tclose(fieldtype1val);
4345  H5Tclose(fieldtype1key);
4346  H5Tclose(item_type0);
4347  H5Tclose(fieldtype0);
4348  break;
4349 
4350  }
4352  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4353  unsigned int total_size0=H5Tget_size(fieldtype0);
4354  hsize_t fieldlen0;
4355  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4356  hid_t item_type0=H5Tget_super(fieldtype0);
4357  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4358  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4359  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
4360  unsigned int total_size1val=H5Tget_size(fieldtype1val);
4361  hsize_t fieldlen1val;
4362  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
4363  hid_t item_type1val=H5Tget_super(fieldtype1val);
4364  unsigned int total_size2valelem=H5Tget_size(item_type1val);
4365  hid_t fieldtype3valelemfirst=H5Tget_member_type(item_type1val, 0);
4366  unsigned int total_size3valelemfirst=H5Tget_size(fieldtype3valelemfirst);
4367  hid_t fieldtype3valelemsecond=H5Tget_member_type(item_type1val, 1);
4368  unsigned int total_size3valelemsecond=H5Tget_size(fieldtype3valelemsecond);
4369  size_t nullpos4valelemsecondfirst;
4370  hid_t fieldtype4valelemsecondfirst=H5Tget_member_type(fieldtype3valelemsecond, 0);
4371  unsigned int total_size4valelemsecondfirst=H5Tget_size(fieldtype4valelemsecondfirst);
4372  hid_t fieldtype4valelemsecondsecond=H5Tget_member_type(fieldtype3valelemsecond, 1);
4373  unsigned int total_size4valelemsecondsecond=H5Tget_size(fieldtype4valelemsecondsecond);
4374  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4375  for(unsigned int k0=0;k0<fieldlen0;++k0){
4376  std::string x1key;
4377  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
4378  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4379  x1val=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen1val);
4380  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
4381  std::pair<int, std::pair<std::string, std::string>> x2valelem;
4382  int x3valelemfirst;
4383  x3valelemfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val);
4384  std::pair<std::string, std::string> x3valelemsecond;
4385  std::string x4valelemsecondfirst;
4386  x4valelemsecondfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst, total_size4valelemsecondfirst);
4387  nullpos4valelemsecondfirst=x4valelemsecondfirst.find('\0');
4388  if(nullpos4valelemsecondfirst!=std::string::npos){
4389  x4valelemsecondfirst.resize(nullpos4valelemsecondfirst);
4390 
4391  }
4392  std::string x4valelemsecondsecond;
4393  x4valelemsecondsecond=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst+total_size4valelemsecondfirst);
4394  x3valelemsecond=std::make_pair(x4valelemsecondfirst, x4valelemsecondsecond);
4395  x2valelem=std::make_pair(x3valelemfirst, x3valelemsecond);
4396  x1val[k1val]=x2valelem;
4397 
4398  }
4399  x0[x1key]=x1val;
4400 
4401  }
4402  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4403  if(is_row_selected){
4404  row[j]=x0;
4405 
4406  }
4407  H5Tclose(fieldtype4valelemsecondsecond);
4408  H5Tclose(fieldtype4valelemsecondfirst);
4409  H5Tclose(fieldtype3valelemsecond);
4410  H5Tclose(fieldtype3valelemfirst);
4411  H5Tclose(item_type1val);
4412  H5Tclose(fieldtype1val);
4413  H5Tclose(fieldtype1key);
4414  H5Tclose(item_type0);
4415  H5Tclose(fieldtype0);
4416  break;
4417 
4418  }
4420  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4421  unsigned int total_size0=H5Tget_size(fieldtype0);
4422  hsize_t fieldlen0;
4423  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4424  hid_t item_type0=H5Tget_super(fieldtype0);
4425  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4426  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4427  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
4428  unsigned int total_size1val=H5Tget_size(fieldtype1val);
4429  hsize_t fieldlen1val;
4430  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
4431  hid_t item_type1val=H5Tget_super(fieldtype1val);
4432  unsigned int total_size2valelem=H5Tget_size(item_type1val);
4433  hid_t fieldtype3valelemfirst=H5Tget_member_type(item_type1val, 0);
4434  unsigned int total_size3valelemfirst=H5Tget_size(fieldtype3valelemfirst);
4435  hid_t fieldtype3valelemsecond=H5Tget_member_type(item_type1val, 1);
4436  unsigned int total_size3valelemsecond=H5Tget_size(fieldtype3valelemsecond);
4437  hid_t fieldtype4valelemsecondfirst=H5Tget_member_type(fieldtype3valelemsecond, 0);
4438  unsigned int total_size4valelemsecondfirst=H5Tget_size(fieldtype4valelemsecondfirst);
4439  size_t nullpos4valelemsecondsecond;
4440  hid_t fieldtype4valelemsecondsecond=H5Tget_member_type(fieldtype3valelemsecond, 1);
4441  unsigned int total_size4valelemsecondsecond=H5Tget_size(fieldtype4valelemsecondsecond);
4442  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4443  for(unsigned int k0=0;k0<fieldlen0;++k0){
4444  std::string x1key;
4445  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
4446  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4447  x1val=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen1val);
4448  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
4449  std::pair<int, std::pair<std::string, std::string>> x2valelem;
4450  int x3valelemfirst;
4451  x3valelemfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val);
4452  std::pair<std::string, std::string> x3valelemsecond;
4453  std::string x4valelemsecondfirst;
4454  x4valelemsecondfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst);
4455  std::string x4valelemsecondsecond;
4456  x4valelemsecondsecond=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst+total_size4valelemsecondfirst, total_size4valelemsecondsecond);
4457  nullpos4valelemsecondsecond=x4valelemsecondsecond.find('\0');
4458  if(nullpos4valelemsecondsecond!=std::string::npos){
4459  x4valelemsecondsecond.resize(nullpos4valelemsecondsecond);
4460 
4461  }
4462  x3valelemsecond=std::make_pair(x4valelemsecondfirst, x4valelemsecondsecond);
4463  x2valelem=std::make_pair(x3valelemfirst, x3valelemsecond);
4464  x1val[k1val]=x2valelem;
4465 
4466  }
4467  x0[x1key]=x1val;
4468 
4469  }
4470  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4471  if(is_row_selected){
4472  row[j]=x0;
4473 
4474  }
4475  H5Tclose(fieldtype4valelemsecondsecond);
4476  H5Tclose(fieldtype4valelemsecondfirst);
4477  H5Tclose(fieldtype3valelemsecond);
4478  H5Tclose(fieldtype3valelemfirst);
4479  H5Tclose(item_type1val);
4480  H5Tclose(fieldtype1val);
4481  H5Tclose(fieldtype1key);
4482  H5Tclose(item_type0);
4483  H5Tclose(fieldtype0);
4484  break;
4485 
4486  }
4488  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4489  unsigned int total_size0=H5Tget_size(fieldtype0);
4490  hsize_t fieldlen0;
4491  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4492  hid_t item_type0=H5Tget_super(fieldtype0);
4493  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4494  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4495  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
4496  unsigned int total_size1val=H5Tget_size(fieldtype1val);
4497  hsize_t fieldlen1val;
4498  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
4499  hid_t item_type1val=H5Tget_super(fieldtype1val);
4500  unsigned int total_size2valelem=H5Tget_size(item_type1val);
4501  hid_t fieldtype3valelemfirst=H5Tget_member_type(item_type1val, 0);
4502  unsigned int total_size3valelemfirst=H5Tget_size(fieldtype3valelemfirst);
4503  hid_t fieldtype3valelemsecond=H5Tget_member_type(item_type1val, 1);
4504  unsigned int total_size3valelemsecond=H5Tget_size(fieldtype3valelemsecond);
4505  hid_t fieldtype4valelemsecondfirst=H5Tget_member_type(fieldtype3valelemsecond, 0);
4506  unsigned int total_size4valelemsecondfirst=H5Tget_size(fieldtype4valelemsecondfirst);
4507  hid_t fieldtype4valelemsecondsecond=H5Tget_member_type(fieldtype3valelemsecond, 1);
4508  unsigned int total_size4valelemsecondsecond=H5Tget_size(fieldtype4valelemsecondsecond);
4509  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4510  for(unsigned int k0=0;k0<fieldlen0;++k0){
4511  std::string x1key;
4512  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
4513  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4514  x1val=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen1val);
4515  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
4516  std::pair<int, std::pair<std::string, std::string>> x2valelem;
4517  int x3valelemfirst;
4518  x3valelemfirst=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val);
4519  std::pair<std::string, std::string> x3valelemsecond;
4520  std::string x4valelemsecondfirst;
4521  x4valelemsecondfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst);
4522  std::string x4valelemsecondsecond;
4523  x4valelemsecondsecond=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valelem*k1val+total_size3valelemfirst+total_size4valelemsecondfirst);
4524  x3valelemsecond=std::make_pair(x4valelemsecondfirst, x4valelemsecondsecond);
4525  x2valelem=std::make_pair(x3valelemfirst, x3valelemsecond);
4526  x1val[k1val]=x2valelem;
4527 
4528  }
4529  x0[x1key]=x1val;
4530 
4531  }
4532  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4533  if(is_row_selected){
4534  row[j]=x0;
4535 
4536  }
4537  H5Tclose(fieldtype4valelemsecondsecond);
4538  H5Tclose(fieldtype4valelemsecondfirst);
4539  H5Tclose(fieldtype3valelemsecond);
4540  H5Tclose(fieldtype3valelemfirst);
4541  H5Tclose(item_type1val);
4542  H5Tclose(fieldtype1val);
4543  H5Tclose(fieldtype1key);
4544  H5Tclose(item_type0);
4545  H5Tclose(fieldtype0);
4546  break;
4547 
4548  }
4550  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4551  unsigned int total_size0=H5Tget_size(fieldtype0);
4552  hsize_t fieldlen0;
4553  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4554  hid_t item_type0=H5Tget_super(fieldtype0);
4555  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4556  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4557  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
4558  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4559  for(unsigned int k0=0;k0<fieldlen0;++k0){
4560  std::string x1key;
4561  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
4562  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4563  x1val=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
4564  x0[x1key]=x1val;
4565 
4566  }
4567  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4568  if(is_row_selected){
4569  row[j]=x0;
4570 
4571  }
4572  H5Tclose(fieldtype1key);
4573  H5Tclose(item_type0);
4574  H5Tclose(fieldtype0);
4575  break;
4576 
4577  }
4579  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4580  unsigned int total_size0=H5Tget_size(fieldtype0);
4581  hsize_t fieldlen0;
4582  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4583  hid_t item_type0=H5Tget_super(fieldtype0);
4584  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4585  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4586  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
4587  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4588  for(unsigned int k0=0;k0<fieldlen0;++k0){
4589  std::string x1key;
4590  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
4591  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4592  x1val=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
4593  x0[x1key]=x1val;
4594 
4595  }
4596  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4597  if(is_row_selected){
4598  row[j]=x0;
4599 
4600  }
4601  H5Tclose(fieldtype1key);
4602  H5Tclose(item_type0);
4603  H5Tclose(fieldtype0);
4604  break;
4605 
4606  }
4608  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4609  unsigned int total_size0=H5Tget_size(fieldtype0);
4610  hsize_t fieldlen0;
4611  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4612  hid_t item_type0=H5Tget_super(fieldtype0);
4613  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4614  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4615  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
4616  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4617  for(unsigned int k0=0;k0<fieldlen0;++k0){
4618  std::string x1key;
4619  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
4620  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4621  x1val=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
4622  x0[x1key]=x1val;
4623 
4624  }
4625  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4626  if(is_row_selected){
4627  row[j]=x0;
4628 
4629  }
4630  H5Tclose(fieldtype1key);
4631  H5Tclose(item_type0);
4632  H5Tclose(fieldtype0);
4633  break;
4634 
4635  }
4637  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4638  unsigned int total_size0=H5Tget_size(fieldtype0);
4639  hsize_t fieldlen0;
4640  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4641  hid_t item_type0=H5Tget_super(fieldtype0);
4642  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4643  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4644  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
4645  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4646  for(unsigned int k0=0;k0<fieldlen0;++k0){
4647  std::string x1key;
4648  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
4649  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val;
4650  x1val=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
4651  x0[x1key]=x1val;
4652 
4653  }
4654  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4655  if(is_row_selected){
4656  row[j]=x0;
4657 
4658  }
4659  H5Tclose(fieldtype1key);
4660  H5Tclose(item_type0);
4661  H5Tclose(fieldtype0);
4662  break;
4663 
4664  }
4666  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4667  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4668  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset);
4669  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4670  if(is_row_selected){
4671  row[j]=x0;
4672 
4673  }
4674  break;
4675 
4676  }
4678  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4679  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4680  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset);
4681  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4682  if(is_row_selected){
4683  row[j]=x0;
4684 
4685  }
4686  break;
4687 
4688  }
4690  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4691  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4692  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset);
4693  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4694  if(is_row_selected){
4695  row[j]=x0;
4696 
4697  }
4698  break;
4699 
4700  }
4702  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4703  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4704  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset);
4705  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4706  if(is_row_selected){
4707  row[j]=x0;
4708 
4709  }
4710  break;
4711 
4712  }
4714  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4715  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4716  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset);
4717  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4718  if(is_row_selected){
4719  row[j]=x0;
4720 
4721  }
4722  break;
4723 
4724  }
4726  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4727  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4728  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset);
4729  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4730  if(is_row_selected){
4731  row[j]=x0;
4732 
4733  }
4734  break;
4735 
4736  }
4738  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4739  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4740  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset);
4741  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4742  if(is_row_selected){
4743  row[j]=x0;
4744 
4745  }
4746  break;
4747 
4748  }
4750  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4751  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4752  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset);
4753  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4754  if(is_row_selected){
4755  row[j]=x0;
4756 
4757  }
4758  break;
4759 
4760  }
4762  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4763  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4764  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset);
4765  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4766  if(is_row_selected){
4767  row[j]=x0;
4768 
4769  }
4770  break;
4771 
4772  }
4774  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4775  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4776  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset);
4777  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4778  if(is_row_selected){
4779  row[j]=x0;
4780 
4781  }
4782  break;
4783 
4784  }
4786  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4787  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4788  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset);
4789  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4790  if(is_row_selected){
4791  row[j]=x0;
4792 
4793  }
4794  break;
4795 
4796  }
4798  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4799  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4800  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset);
4801  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4802  if(is_row_selected){
4803  row[j]=x0;
4804 
4805  }
4806  break;
4807 
4808  }
4810  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4811  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4812  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset);
4813  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4814  if(is_row_selected){
4815  row[j]=x0;
4816 
4817  }
4818  break;
4819 
4820  }
4822  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4823  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4824  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset);
4825  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4826  if(is_row_selected){
4827  row[j]=x0;
4828 
4829  }
4830  break;
4831 
4832  }
4834  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4835  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4836  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset);
4837  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4838  if(is_row_selected){
4839  row[j]=x0;
4840 
4841  }
4842  break;
4843 
4844  }
4846  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4847  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
4848  x0=VLRead<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>,VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset);
4849  is_row_selected=CmpConds<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(&x0, &(field_conds[qr.fields[j]]));
4850  if(is_row_selected){
4851  row[j]=x0;
4852 
4853  }
4854  break;
4855 
4856  }
4857  case LIST_PAIR_INT_INT: {
4858  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4859  unsigned int total_size0=H5Tget_size(fieldtype0);
4860  hsize_t fieldlen0;
4861  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4862  hid_t item_type0=H5Tget_super(fieldtype0);
4863  unsigned int total_size1elem=H5Tget_size(item_type0);
4864  hid_t fieldtype2elemfirst=H5Tget_member_type(item_type0, 0);
4865  unsigned int total_size2elemfirst=H5Tget_size(fieldtype2elemfirst);
4866  hid_t fieldtype2elemsecond=H5Tget_member_type(item_type0, 1);
4867  unsigned int total_size2elemsecond=H5Tget_size(fieldtype2elemsecond);
4868  std::list<std::pair<int, int>> x0;
4869  for(unsigned int k0=0;k0<fieldlen0;++k0){
4870  std::pair<int, int> x1elem;
4871  int x2elemfirst;
4872  x2elemfirst=*reinterpret_cast<int*>(buf+offset+total_size1elem*k0);
4873  int x2elemsecond;
4874  x2elemsecond=*reinterpret_cast<int*>(buf+offset+total_size1elem*k0+total_size2elemfirst);
4875  x1elem=std::make_pair(x2elemfirst, x2elemsecond);
4876  x0.push_back(x1elem);
4877 
4878  }
4879  is_row_selected=CmpConds<std::list<std::pair<int, int>>>(&x0, &(field_conds[qr.fields[j]]));
4880  if(is_row_selected){
4881  row[j]=x0;
4882 
4883  }
4884  H5Tclose(fieldtype2elemsecond);
4885  H5Tclose(fieldtype2elemfirst);
4886  H5Tclose(item_type0);
4887  H5Tclose(fieldtype0);
4888  break;
4889 
4890  }
4891  case VL_LIST_PAIR_INT_INT: {
4892  unsigned int total_size0=CYCLUS_SHA1_SIZE;
4893  std::list<std::pair<int, int>> x0;
4894  x0=VLRead<std::list<std::pair<int, int>>,VL_LIST_PAIR_INT_INT>(buf+offset);
4895  is_row_selected=CmpConds<std::list<std::pair<int, int>>>(&x0, &(field_conds[qr.fields[j]]));
4896  if(is_row_selected){
4897  row[j]=x0;
4898 
4899  }
4900  break;
4901 
4902  }
4904  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4905  unsigned int total_size0=H5Tget_size(fieldtype0);
4906  hsize_t fieldlen0;
4907  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4908  hid_t item_type0=H5Tget_super(fieldtype0);
4909  size_t nullpos1key;
4910  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4911  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4912  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
4913  unsigned int total_size1val=H5Tget_size(fieldtype1val);
4914  size_t nullpos2valfirst;
4915  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
4916  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
4917  hid_t fieldtype2valsecond=H5Tget_member_type(fieldtype1val, 1);
4918  unsigned int total_size2valsecond=H5Tget_size(fieldtype2valsecond);
4919  hsize_t fieldlen2valsecond;
4920  H5Tget_array_dims2(fieldtype2valsecond, &fieldlen2valsecond);
4921  hid_t item_type2valsecond=H5Tget_super(fieldtype2valsecond);
4922  unsigned int total_size3valsecondelem=H5Tget_size(item_type2valsecond);
4923  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
4924  for(unsigned int k0=0;k0<fieldlen0;++k0){
4925  std::string x1key;
4926  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
4927  nullpos1key=x1key.find('\0');
4928  if(nullpos1key!=std::string::npos){
4929  x1key.resize(nullpos1key);
4930 
4931  }
4932  std::pair<std::string, std::vector<double>> x1val;
4933  std::string x2valfirst;
4934  x2valfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size2valfirst);
4935  nullpos2valfirst=x2valfirst.find('\0');
4936  if(nullpos2valfirst!=std::string::npos){
4937  x2valfirst.resize(nullpos2valfirst);
4938 
4939  }
4940  std::vector<double> x2valsecond;
4941  x2valsecond=std::vector<double>(fieldlen2valsecond);
4942  memcpy(&x2valsecond[0], buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst, total_size2valsecond);
4943  x1val=std::make_pair(x2valfirst, x2valsecond);
4944  x0[x1key]=x1val;
4945 
4946  }
4947  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
4948  if(is_row_selected){
4949  row[j]=x0;
4950 
4951  }
4952  H5Tclose(item_type2valsecond);
4953  H5Tclose(fieldtype2valsecond);
4954  H5Tclose(fieldtype2valfirst);
4955  H5Tclose(fieldtype1val);
4956  H5Tclose(fieldtype1key);
4957  H5Tclose(item_type0);
4958  H5Tclose(fieldtype0);
4959  break;
4960 
4961  }
4963  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
4964  unsigned int total_size0=H5Tget_size(fieldtype0);
4965  hsize_t fieldlen0;
4966  H5Tget_array_dims2(fieldtype0, &fieldlen0);
4967  hid_t item_type0=H5Tget_super(fieldtype0);
4968  size_t nullpos1key;
4969  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
4970  unsigned int total_size1key=H5Tget_size(fieldtype1key);
4971  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
4972  unsigned int total_size1val=H5Tget_size(fieldtype1val);
4973  size_t nullpos2valfirst;
4974  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
4975  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
4976  unsigned int total_size2valsecond=CYCLUS_SHA1_SIZE;
4977  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
4978  for(unsigned int k0=0;k0<fieldlen0;++k0){
4979  std::string x1key;
4980  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
4981  nullpos1key=x1key.find('\0');
4982  if(nullpos1key!=std::string::npos){
4983  x1key.resize(nullpos1key);
4984 
4985  }
4986  std::pair<std::string, std::vector<double>> x1val;
4987  std::string x2valfirst;
4988  x2valfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size2valfirst);
4989  nullpos2valfirst=x2valfirst.find('\0');
4990  if(nullpos2valfirst!=std::string::npos){
4991  x2valfirst.resize(nullpos2valfirst);
4992 
4993  }
4994  std::vector<double> x2valsecond;
4995  x2valsecond=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst);
4996  x1val=std::make_pair(x2valfirst, x2valsecond);
4997  x0[x1key]=x1val;
4998 
4999  }
5000  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5001  if(is_row_selected){
5002  row[j]=x0;
5003 
5004  }
5005  H5Tclose(fieldtype2valfirst);
5006  H5Tclose(fieldtype1val);
5007  H5Tclose(fieldtype1key);
5008  H5Tclose(item_type0);
5009  H5Tclose(fieldtype0);
5010  break;
5011 
5012  }
5014  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5015  unsigned int total_size0=H5Tget_size(fieldtype0);
5016  hsize_t fieldlen0;
5017  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5018  hid_t item_type0=H5Tget_super(fieldtype0);
5019  size_t nullpos1key;
5020  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5021  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5022  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5023  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5024  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
5025  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
5026  hid_t fieldtype2valsecond=H5Tget_member_type(fieldtype1val, 1);
5027  unsigned int total_size2valsecond=H5Tget_size(fieldtype2valsecond);
5028  hsize_t fieldlen2valsecond;
5029  H5Tget_array_dims2(fieldtype2valsecond, &fieldlen2valsecond);
5030  hid_t item_type2valsecond=H5Tget_super(fieldtype2valsecond);
5031  unsigned int total_size3valsecondelem=H5Tget_size(item_type2valsecond);
5032  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5033  for(unsigned int k0=0;k0<fieldlen0;++k0){
5034  std::string x1key;
5035  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
5036  nullpos1key=x1key.find('\0');
5037  if(nullpos1key!=std::string::npos){
5038  x1key.resize(nullpos1key);
5039 
5040  }
5041  std::pair<std::string, std::vector<double>> x1val;
5042  std::string x2valfirst;
5043  x2valfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
5044  std::vector<double> x2valsecond;
5045  x2valsecond=std::vector<double>(fieldlen2valsecond);
5046  memcpy(&x2valsecond[0], buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst, total_size2valsecond);
5047  x1val=std::make_pair(x2valfirst, x2valsecond);
5048  x0[x1key]=x1val;
5049 
5050  }
5051  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5052  if(is_row_selected){
5053  row[j]=x0;
5054 
5055  }
5056  H5Tclose(item_type2valsecond);
5057  H5Tclose(fieldtype2valsecond);
5058  H5Tclose(fieldtype2valfirst);
5059  H5Tclose(fieldtype1val);
5060  H5Tclose(fieldtype1key);
5061  H5Tclose(item_type0);
5062  H5Tclose(fieldtype0);
5063  break;
5064 
5065  }
5067  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5068  unsigned int total_size0=H5Tget_size(fieldtype0);
5069  hsize_t fieldlen0;
5070  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5071  hid_t item_type0=H5Tget_super(fieldtype0);
5072  size_t nullpos1key;
5073  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5074  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5075  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5076  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5077  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
5078  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
5079  unsigned int total_size2valsecond=CYCLUS_SHA1_SIZE;
5080  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5081  for(unsigned int k0=0;k0<fieldlen0;++k0){
5082  std::string x1key;
5083  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
5084  nullpos1key=x1key.find('\0');
5085  if(nullpos1key!=std::string::npos){
5086  x1key.resize(nullpos1key);
5087 
5088  }
5089  std::pair<std::string, std::vector<double>> x1val;
5090  std::string x2valfirst;
5091  x2valfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
5092  std::vector<double> x2valsecond;
5093  x2valsecond=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst);
5094  x1val=std::make_pair(x2valfirst, x2valsecond);
5095  x0[x1key]=x1val;
5096 
5097  }
5098  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5099  if(is_row_selected){
5100  row[j]=x0;
5101 
5102  }
5103  H5Tclose(fieldtype2valfirst);
5104  H5Tclose(fieldtype1val);
5105  H5Tclose(fieldtype1key);
5106  H5Tclose(item_type0);
5107  H5Tclose(fieldtype0);
5108  break;
5109 
5110  }
5112  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5113  unsigned int total_size0=H5Tget_size(fieldtype0);
5114  hsize_t fieldlen0;
5115  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5116  hid_t item_type0=H5Tget_super(fieldtype0);
5117  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5118  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5119  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5120  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5121  size_t nullpos2valfirst;
5122  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
5123  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
5124  hid_t fieldtype2valsecond=H5Tget_member_type(fieldtype1val, 1);
5125  unsigned int total_size2valsecond=H5Tget_size(fieldtype2valsecond);
5126  hsize_t fieldlen2valsecond;
5127  H5Tget_array_dims2(fieldtype2valsecond, &fieldlen2valsecond);
5128  hid_t item_type2valsecond=H5Tget_super(fieldtype2valsecond);
5129  unsigned int total_size3valsecondelem=H5Tget_size(item_type2valsecond);
5130  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5131  for(unsigned int k0=0;k0<fieldlen0;++k0){
5132  std::string x1key;
5133  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
5134  std::pair<std::string, std::vector<double>> x1val;
5135  std::string x2valfirst;
5136  x2valfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size2valfirst);
5137  nullpos2valfirst=x2valfirst.find('\0');
5138  if(nullpos2valfirst!=std::string::npos){
5139  x2valfirst.resize(nullpos2valfirst);
5140 
5141  }
5142  std::vector<double> x2valsecond;
5143  x2valsecond=std::vector<double>(fieldlen2valsecond);
5144  memcpy(&x2valsecond[0], buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst, total_size2valsecond);
5145  x1val=std::make_pair(x2valfirst, x2valsecond);
5146  x0[x1key]=x1val;
5147 
5148  }
5149  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5150  if(is_row_selected){
5151  row[j]=x0;
5152 
5153  }
5154  H5Tclose(item_type2valsecond);
5155  H5Tclose(fieldtype2valsecond);
5156  H5Tclose(fieldtype2valfirst);
5157  H5Tclose(fieldtype1val);
5158  H5Tclose(fieldtype1key);
5159  H5Tclose(item_type0);
5160  H5Tclose(fieldtype0);
5161  break;
5162 
5163  }
5165  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5166  unsigned int total_size0=H5Tget_size(fieldtype0);
5167  hsize_t fieldlen0;
5168  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5169  hid_t item_type0=H5Tget_super(fieldtype0);
5170  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5171  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5172  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5173  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5174  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
5175  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
5176  hid_t fieldtype2valsecond=H5Tget_member_type(fieldtype1val, 1);
5177  unsigned int total_size2valsecond=H5Tget_size(fieldtype2valsecond);
5178  hsize_t fieldlen2valsecond;
5179  H5Tget_array_dims2(fieldtype2valsecond, &fieldlen2valsecond);
5180  hid_t item_type2valsecond=H5Tget_super(fieldtype2valsecond);
5181  unsigned int total_size3valsecondelem=H5Tget_size(item_type2valsecond);
5182  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5183  for(unsigned int k0=0;k0<fieldlen0;++k0){
5184  std::string x1key;
5185  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
5186  std::pair<std::string, std::vector<double>> x1val;
5187  std::string x2valfirst;
5188  x2valfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
5189  std::vector<double> x2valsecond;
5190  x2valsecond=std::vector<double>(fieldlen2valsecond);
5191  memcpy(&x2valsecond[0], buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst, total_size2valsecond);
5192  x1val=std::make_pair(x2valfirst, x2valsecond);
5193  x0[x1key]=x1val;
5194 
5195  }
5196  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5197  if(is_row_selected){
5198  row[j]=x0;
5199 
5200  }
5201  H5Tclose(item_type2valsecond);
5202  H5Tclose(fieldtype2valsecond);
5203  H5Tclose(fieldtype2valfirst);
5204  H5Tclose(fieldtype1val);
5205  H5Tclose(fieldtype1key);
5206  H5Tclose(item_type0);
5207  H5Tclose(fieldtype0);
5208  break;
5209 
5210  }
5212  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5213  unsigned int total_size0=H5Tget_size(fieldtype0);
5214  hsize_t fieldlen0;
5215  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5216  hid_t item_type0=H5Tget_super(fieldtype0);
5217  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5218  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5219  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5220  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5221  size_t nullpos2valfirst;
5222  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
5223  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
5224  unsigned int total_size2valsecond=CYCLUS_SHA1_SIZE;
5225  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5226  for(unsigned int k0=0;k0<fieldlen0;++k0){
5227  std::string x1key;
5228  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
5229  std::pair<std::string, std::vector<double>> x1val;
5230  std::string x2valfirst;
5231  x2valfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key, total_size2valfirst);
5232  nullpos2valfirst=x2valfirst.find('\0');
5233  if(nullpos2valfirst!=std::string::npos){
5234  x2valfirst.resize(nullpos2valfirst);
5235 
5236  }
5237  std::vector<double> x2valsecond;
5238  x2valsecond=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst);
5239  x1val=std::make_pair(x2valfirst, x2valsecond);
5240  x0[x1key]=x1val;
5241 
5242  }
5243  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5244  if(is_row_selected){
5245  row[j]=x0;
5246 
5247  }
5248  H5Tclose(fieldtype2valfirst);
5249  H5Tclose(fieldtype1val);
5250  H5Tclose(fieldtype1key);
5251  H5Tclose(item_type0);
5252  H5Tclose(fieldtype0);
5253  break;
5254 
5255  }
5257  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5258  unsigned int total_size0=H5Tget_size(fieldtype0);
5259  hsize_t fieldlen0;
5260  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5261  hid_t item_type0=H5Tget_super(fieldtype0);
5262  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5263  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5264  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5265  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5266  hid_t fieldtype2valfirst=H5Tget_member_type(fieldtype1val, 0);
5267  unsigned int total_size2valfirst=H5Tget_size(fieldtype2valfirst);
5268  unsigned int total_size2valsecond=CYCLUS_SHA1_SIZE;
5269  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5270  for(unsigned int k0=0;k0<fieldlen0;++k0){
5271  std::string x1key;
5272  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
5273  std::pair<std::string, std::vector<double>> x1val;
5274  std::string x2valfirst;
5275  x2valfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
5276  std::vector<double> x2valsecond;
5277  x2valsecond=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+total_size2valfirst);
5278  x1val=std::make_pair(x2valfirst, x2valsecond);
5279  x0[x1key]=x1val;
5280 
5281  }
5282  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5283  if(is_row_selected){
5284  row[j]=x0;
5285 
5286  }
5287  H5Tclose(fieldtype2valfirst);
5288  H5Tclose(fieldtype1val);
5289  H5Tclose(fieldtype1key);
5290  H5Tclose(item_type0);
5291  H5Tclose(fieldtype0);
5292  break;
5293 
5294  }
5296  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5297  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5298  x0=VLRead<std::map<std::string, std::pair<std::string, std::vector<double>>>,VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset);
5299  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5300  if(is_row_selected){
5301  row[j]=x0;
5302 
5303  }
5304  break;
5305 
5306  }
5308  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5309  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5310  x0=VLRead<std::map<std::string, std::pair<std::string, std::vector<double>>>,VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset);
5311  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5312  if(is_row_selected){
5313  row[j]=x0;
5314 
5315  }
5316  break;
5317 
5318  }
5320  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5321  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5322  x0=VLRead<std::map<std::string, std::pair<std::string, std::vector<double>>>,VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset);
5323  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5324  if(is_row_selected){
5325  row[j]=x0;
5326 
5327  }
5328  break;
5329 
5330  }
5332  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5333  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5334  x0=VLRead<std::map<std::string, std::pair<std::string, std::vector<double>>>,VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset);
5335  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5336  if(is_row_selected){
5337  row[j]=x0;
5338 
5339  }
5340  break;
5341 
5342  }
5344  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5345  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5346  x0=VLRead<std::map<std::string, std::pair<std::string, std::vector<double>>>,VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset);
5347  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5348  if(is_row_selected){
5349  row[j]=x0;
5350 
5351  }
5352  break;
5353 
5354  }
5356  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5357  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5358  x0=VLRead<std::map<std::string, std::pair<std::string, std::vector<double>>>,VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset);
5359  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5360  if(is_row_selected){
5361  row[j]=x0;
5362 
5363  }
5364  break;
5365 
5366  }
5368  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5369  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5370  x0=VLRead<std::map<std::string, std::pair<std::string, std::vector<double>>>,VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset);
5371  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5372  if(is_row_selected){
5373  row[j]=x0;
5374 
5375  }
5376  break;
5377 
5378  }
5380  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5381  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
5382  x0=VLRead<std::map<std::string, std::pair<std::string, std::vector<double>>>,VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset);
5383  is_row_selected=CmpConds<std::map<std::string, std::pair<std::string, std::vector<double>>>>(&x0, &(field_conds[qr.fields[j]]));
5384  if(is_row_selected){
5385  row[j]=x0;
5386 
5387  }
5388  break;
5389 
5390  }
5392  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5393  unsigned int total_size0=H5Tget_size(fieldtype0);
5394  hsize_t fieldlen0;
5395  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5396  hid_t item_type0=H5Tget_super(fieldtype0);
5397  size_t nullpos1key;
5398  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5399  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5400  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5401  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5402  hsize_t fieldlen1val;
5403  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
5404  hid_t item_type1val=H5Tget_super(fieldtype1val);
5405  size_t nullpos2valkey;
5406  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
5407  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
5408  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
5409  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
5410  std::map<std::string, std::map<std::string, int>> x0;
5411  for(unsigned int k0=0;k0<fieldlen0;++k0){
5412  std::string x1key;
5413  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
5414  nullpos1key=x1key.find('\0');
5415  if(nullpos1key!=std::string::npos){
5416  x1key.resize(nullpos1key);
5417 
5418  }
5419  std::map<std::string, int> x1val;
5420  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
5421  std::string x2valkey;
5422  x2valkey=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val, total_size2valkey);
5423  nullpos2valkey=x2valkey.find('\0');
5424  if(nullpos2valkey!=std::string::npos){
5425  x2valkey.resize(nullpos2valkey);
5426 
5427  }
5428  int x2valval;
5429  x2valval=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
5430  x1val[x2valkey]=x2valval;
5431 
5432  }
5433  x0[x1key]=x1val;
5434 
5435  }
5436  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5437  if(is_row_selected){
5438  row[j]=x0;
5439 
5440  }
5441  H5Tclose(fieldtype2valval);
5442  H5Tclose(fieldtype2valkey);
5443  H5Tclose(item_type1val);
5444  H5Tclose(fieldtype1val);
5445  H5Tclose(fieldtype1key);
5446  H5Tclose(item_type0);
5447  H5Tclose(fieldtype0);
5448  break;
5449 
5450  }
5452  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5453  unsigned int total_size0=H5Tget_size(fieldtype0);
5454  hsize_t fieldlen0;
5455  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5456  hid_t item_type0=H5Tget_super(fieldtype0);
5457  size_t nullpos1key;
5458  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5459  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5460  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5461  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5462  hsize_t fieldlen1val;
5463  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
5464  hid_t item_type1val=H5Tget_super(fieldtype1val);
5465  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
5466  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
5467  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
5468  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
5469  std::map<std::string, std::map<std::string, int>> x0;
5470  for(unsigned int k0=0;k0<fieldlen0;++k0){
5471  std::string x1key;
5472  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
5473  nullpos1key=x1key.find('\0');
5474  if(nullpos1key!=std::string::npos){
5475  x1key.resize(nullpos1key);
5476 
5477  }
5478  std::map<std::string, int> x1val;
5479  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
5480  std::string x2valkey;
5481  x2valkey=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val);
5482  int x2valval;
5483  x2valval=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
5484  x1val[x2valkey]=x2valval;
5485 
5486  }
5487  x0[x1key]=x1val;
5488 
5489  }
5490  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5491  if(is_row_selected){
5492  row[j]=x0;
5493 
5494  }
5495  H5Tclose(fieldtype2valval);
5496  H5Tclose(fieldtype2valkey);
5497  H5Tclose(item_type1val);
5498  H5Tclose(fieldtype1val);
5499  H5Tclose(fieldtype1key);
5500  H5Tclose(item_type0);
5501  H5Tclose(fieldtype0);
5502  break;
5503 
5504  }
5506  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5507  unsigned int total_size0=H5Tget_size(fieldtype0);
5508  hsize_t fieldlen0;
5509  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5510  hid_t item_type0=H5Tget_super(fieldtype0);
5511  size_t nullpos1key;
5512  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5513  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5514  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
5515  std::map<std::string, std::map<std::string, int>> x0;
5516  for(unsigned int k0=0;k0<fieldlen0;++k0){
5517  std::string x1key;
5518  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
5519  nullpos1key=x1key.find('\0');
5520  if(nullpos1key!=std::string::npos){
5521  x1key.resize(nullpos1key);
5522 
5523  }
5524  std::map<std::string, int> x1val;
5525  x1val=VLRead<std::map<std::string, int>,VL_MAP_STRING_INT>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
5526  x0[x1key]=x1val;
5527 
5528  }
5529  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5530  if(is_row_selected){
5531  row[j]=x0;
5532 
5533  }
5534  H5Tclose(fieldtype1key);
5535  H5Tclose(item_type0);
5536  H5Tclose(fieldtype0);
5537  break;
5538 
5539  }
5541  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5542  unsigned int total_size0=H5Tget_size(fieldtype0);
5543  hsize_t fieldlen0;
5544  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5545  hid_t item_type0=H5Tget_super(fieldtype0);
5546  size_t nullpos1key;
5547  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5548  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5549  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
5550  std::map<std::string, std::map<std::string, int>> x0;
5551  for(unsigned int k0=0;k0<fieldlen0;++k0){
5552  std::string x1key;
5553  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
5554  nullpos1key=x1key.find('\0');
5555  if(nullpos1key!=std::string::npos){
5556  x1key.resize(nullpos1key);
5557 
5558  }
5559  std::map<std::string, int> x1val;
5560  x1val=VLRead<std::map<std::string, int>,VL_MAP_VL_STRING_INT>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
5561  x0[x1key]=x1val;
5562 
5563  }
5564  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5565  if(is_row_selected){
5566  row[j]=x0;
5567 
5568  }
5569  H5Tclose(fieldtype1key);
5570  H5Tclose(item_type0);
5571  H5Tclose(fieldtype0);
5572  break;
5573 
5574  }
5576  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5577  unsigned int total_size0=H5Tget_size(fieldtype0);
5578  hsize_t fieldlen0;
5579  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5580  hid_t item_type0=H5Tget_super(fieldtype0);
5581  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5582  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5583  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5584  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5585  hsize_t fieldlen1val;
5586  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
5587  hid_t item_type1val=H5Tget_super(fieldtype1val);
5588  size_t nullpos2valkey;
5589  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
5590  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
5591  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
5592  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
5593  std::map<std::string, std::map<std::string, int>> x0;
5594  for(unsigned int k0=0;k0<fieldlen0;++k0){
5595  std::string x1key;
5596  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
5597  std::map<std::string, int> x1val;
5598  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
5599  std::string x2valkey;
5600  x2valkey=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val, total_size2valkey);
5601  nullpos2valkey=x2valkey.find('\0');
5602  if(nullpos2valkey!=std::string::npos){
5603  x2valkey.resize(nullpos2valkey);
5604 
5605  }
5606  int x2valval;
5607  x2valval=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
5608  x1val[x2valkey]=x2valval;
5609 
5610  }
5611  x0[x1key]=x1val;
5612 
5613  }
5614  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5615  if(is_row_selected){
5616  row[j]=x0;
5617 
5618  }
5619  H5Tclose(fieldtype2valval);
5620  H5Tclose(fieldtype2valkey);
5621  H5Tclose(item_type1val);
5622  H5Tclose(fieldtype1val);
5623  H5Tclose(fieldtype1key);
5624  H5Tclose(item_type0);
5625  H5Tclose(fieldtype0);
5626  break;
5627 
5628  }
5630  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5631  unsigned int total_size0=H5Tget_size(fieldtype0);
5632  hsize_t fieldlen0;
5633  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5634  hid_t item_type0=H5Tget_super(fieldtype0);
5635  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5636  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5637  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
5638  std::map<std::string, std::map<std::string, int>> x0;
5639  for(unsigned int k0=0;k0<fieldlen0;++k0){
5640  std::string x1key;
5641  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
5642  std::map<std::string, int> x1val;
5643  x1val=VLRead<std::map<std::string, int>,VL_MAP_STRING_INT>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
5644  x0[x1key]=x1val;
5645 
5646  }
5647  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5648  if(is_row_selected){
5649  row[j]=x0;
5650 
5651  }
5652  H5Tclose(fieldtype1key);
5653  H5Tclose(item_type0);
5654  H5Tclose(fieldtype0);
5655  break;
5656 
5657  }
5659  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5660  unsigned int total_size0=H5Tget_size(fieldtype0);
5661  hsize_t fieldlen0;
5662  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5663  hid_t item_type0=H5Tget_super(fieldtype0);
5664  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5665  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5666  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
5667  unsigned int total_size1val=H5Tget_size(fieldtype1val);
5668  hsize_t fieldlen1val;
5669  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
5670  hid_t item_type1val=H5Tget_super(fieldtype1val);
5671  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
5672  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
5673  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
5674  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
5675  std::map<std::string, std::map<std::string, int>> x0;
5676  for(unsigned int k0=0;k0<fieldlen0;++k0){
5677  std::string x1key;
5678  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
5679  std::map<std::string, int> x1val;
5680  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
5681  std::string x2valkey;
5682  x2valkey=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val);
5683  int x2valval;
5684  x2valval=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
5685  x1val[x2valkey]=x2valval;
5686 
5687  }
5688  x0[x1key]=x1val;
5689 
5690  }
5691  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5692  if(is_row_selected){
5693  row[j]=x0;
5694 
5695  }
5696  H5Tclose(fieldtype2valval);
5697  H5Tclose(fieldtype2valkey);
5698  H5Tclose(item_type1val);
5699  H5Tclose(fieldtype1val);
5700  H5Tclose(fieldtype1key);
5701  H5Tclose(item_type0);
5702  H5Tclose(fieldtype0);
5703  break;
5704 
5705  }
5707  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5708  unsigned int total_size0=H5Tget_size(fieldtype0);
5709  hsize_t fieldlen0;
5710  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5711  hid_t item_type0=H5Tget_super(fieldtype0);
5712  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
5713  unsigned int total_size1key=H5Tget_size(fieldtype1key);
5714  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
5715  std::map<std::string, std::map<std::string, int>> x0;
5716  for(unsigned int k0=0;k0<fieldlen0;++k0){
5717  std::string x1key;
5718  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
5719  std::map<std::string, int> x1val;
5720  x1val=VLRead<std::map<std::string, int>,VL_MAP_VL_STRING_INT>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
5721  x0[x1key]=x1val;
5722 
5723  }
5724  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5725  if(is_row_selected){
5726  row[j]=x0;
5727 
5728  }
5729  H5Tclose(fieldtype1key);
5730  H5Tclose(item_type0);
5731  H5Tclose(fieldtype0);
5732  break;
5733 
5734  }
5736  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5737  std::map<std::string, std::map<std::string, int>> x0;
5738  x0=VLRead<std::map<std::string, std::map<std::string, int>>,VL_MAP_STRING_MAP_STRING_INT>(buf+offset);
5739  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5740  if(is_row_selected){
5741  row[j]=x0;
5742 
5743  }
5744  break;
5745 
5746  }
5748  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5749  std::map<std::string, std::map<std::string, int>> x0;
5750  x0=VLRead<std::map<std::string, std::map<std::string, int>>,VL_MAP_VL_STRING_MAP_STRING_INT>(buf+offset);
5751  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5752  if(is_row_selected){
5753  row[j]=x0;
5754 
5755  }
5756  break;
5757 
5758  }
5760  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5761  std::map<std::string, std::map<std::string, int>> x0;
5762  x0=VLRead<std::map<std::string, std::map<std::string, int>>,VL_MAP_STRING_VL_MAP_STRING_INT>(buf+offset);
5763  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5764  if(is_row_selected){
5765  row[j]=x0;
5766 
5767  }
5768  break;
5769 
5770  }
5772  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5773  std::map<std::string, std::map<std::string, int>> x0;
5774  x0=VLRead<std::map<std::string, std::map<std::string, int>>,VL_MAP_STRING_MAP_VL_STRING_INT>(buf+offset);
5775  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5776  if(is_row_selected){
5777  row[j]=x0;
5778 
5779  }
5780  break;
5781 
5782  }
5784  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5785  std::map<std::string, std::map<std::string, int>> x0;
5786  x0=VLRead<std::map<std::string, std::map<std::string, int>>,VL_MAP_STRING_VL_MAP_VL_STRING_INT>(buf+offset);
5787  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5788  if(is_row_selected){
5789  row[j]=x0;
5790 
5791  }
5792  break;
5793 
5794  }
5796  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5797  std::map<std::string, std::map<std::string, int>> x0;
5798  x0=VLRead<std::map<std::string, std::map<std::string, int>>,VL_MAP_VL_STRING_MAP_VL_STRING_INT>(buf+offset);
5799  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5800  if(is_row_selected){
5801  row[j]=x0;
5802 
5803  }
5804  break;
5805 
5806  }
5808  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5809  std::map<std::string, std::map<std::string, int>> x0;
5810  x0=VLRead<std::map<std::string, std::map<std::string, int>>,VL_MAP_VL_STRING_VL_MAP_STRING_INT>(buf+offset);
5811  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5812  if(is_row_selected){
5813  row[j]=x0;
5814 
5815  }
5816  break;
5817 
5818  }
5820  unsigned int total_size0=CYCLUS_SHA1_SIZE;
5821  std::map<std::string, std::map<std::string, int>> x0;
5822  x0=VLRead<std::map<std::string, std::map<std::string, int>>,VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT>(buf+offset);
5823  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, int>>>(&x0, &(field_conds[qr.fields[j]]));
5824  if(is_row_selected){
5825  row[j]=x0;
5826 
5827  }
5828  break;
5829 
5830  }
5832  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5833  unsigned int total_size0=H5Tget_size(fieldtype0);
5834  hsize_t fieldlen0;
5835  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5836  hid_t item_type0=H5Tget_super(fieldtype0);
5837  unsigned int total_size1elem=H5Tget_size(item_type0);
5838  hid_t fieldtype2elemfirst=H5Tget_member_type(item_type0, 0);
5839  unsigned int total_size2elemfirst=H5Tget_size(fieldtype2elemfirst);
5840  hid_t fieldtype3elemfirstfirst=H5Tget_member_type(fieldtype2elemfirst, 0);
5841  unsigned int total_size3elemfirstfirst=H5Tget_size(fieldtype3elemfirstfirst);
5842  hid_t fieldtype3elemfirstsecond=H5Tget_member_type(fieldtype2elemfirst, 1);
5843  unsigned int total_size3elemfirstsecond=H5Tget_size(fieldtype3elemfirstsecond);
5844  hid_t fieldtype2elemsecond=H5Tget_member_type(item_type0, 1);
5845  unsigned int total_size2elemsecond=H5Tget_size(fieldtype2elemsecond);
5846  hsize_t fieldlen2elemsecond;
5847  H5Tget_array_dims2(fieldtype2elemsecond, &fieldlen2elemsecond);
5848  hid_t item_type2elemsecond=H5Tget_super(fieldtype2elemsecond);
5849  size_t nullpos3elemsecondkey;
5850  hid_t fieldtype3elemsecondkey=H5Tget_member_type(item_type2elemsecond, 0);
5851  unsigned int total_size3elemsecondkey=H5Tget_size(fieldtype3elemsecondkey);
5852  hid_t fieldtype3elemsecondval=H5Tget_member_type(item_type2elemsecond, 1);
5853  unsigned int total_size3elemsecondval=H5Tget_size(fieldtype3elemsecondval);
5854  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
5855  x0=std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>(fieldlen0);
5856  for(unsigned int k0=0;k0<fieldlen0;++k0){
5857  std::pair<std::pair<double, double>, std::map<std::string, double>> x1elem;
5858  std::pair<double, double> x2elemfirst;
5859  double x3elemfirstfirst;
5860  x3elemfirstfirst=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0);
5861  double x3elemfirstsecond;
5862  x3elemfirstsecond=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0+total_size3elemfirstfirst);
5863  x2elemfirst=std::make_pair(x3elemfirstfirst, x3elemfirstsecond);
5864  std::map<std::string, double> x2elemsecond;
5865  for(unsigned int k2elemsecond=0;k2elemsecond<fieldlen2elemsecond;++k2elemsecond){
5866  std::string x3elemsecondkey;
5867  x3elemsecondkey=std::string(buf+offset+total_size1elem*k0+total_size2elemfirst+(total_size3elemsecondkey+total_size3elemsecondval)*k2elemsecond, total_size3elemsecondkey);
5868  nullpos3elemsecondkey=x3elemsecondkey.find('\0');
5869  if(nullpos3elemsecondkey!=std::string::npos){
5870  x3elemsecondkey.resize(nullpos3elemsecondkey);
5871 
5872  }
5873  double x3elemsecondval;
5874  x3elemsecondval=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0+total_size2elemfirst+(total_size3elemsecondkey+total_size3elemsecondval)*k2elemsecond+total_size3elemsecondkey);
5875  x2elemsecond[x3elemsecondkey]=x3elemsecondval;
5876 
5877  }
5878  x1elem=std::make_pair(x2elemfirst, x2elemsecond);
5879  x0[k0]=x1elem;
5880 
5881  }
5882  is_row_selected=CmpConds<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>(&x0, &(field_conds[qr.fields[j]]));
5883  if(is_row_selected){
5884  row[j]=x0;
5885 
5886  }
5887  H5Tclose(fieldtype3elemsecondval);
5888  H5Tclose(fieldtype3elemsecondkey);
5889  H5Tclose(item_type2elemsecond);
5890  H5Tclose(fieldtype2elemsecond);
5891  H5Tclose(fieldtype3elemfirstsecond);
5892  H5Tclose(fieldtype3elemfirstfirst);
5893  H5Tclose(fieldtype2elemfirst);
5894  H5Tclose(item_type0);
5895  H5Tclose(fieldtype0);
5896  break;
5897 
5898  }
5900  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5901  unsigned int total_size0=H5Tget_size(fieldtype0);
5902  hsize_t fieldlen0;
5903  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5904  hid_t item_type0=H5Tget_super(fieldtype0);
5905  unsigned int total_size1elem=H5Tget_size(item_type0);
5906  hid_t fieldtype2elemfirst=H5Tget_member_type(item_type0, 0);
5907  unsigned int total_size2elemfirst=H5Tget_size(fieldtype2elemfirst);
5908  hid_t fieldtype3elemfirstfirst=H5Tget_member_type(fieldtype2elemfirst, 0);
5909  unsigned int total_size3elemfirstfirst=H5Tget_size(fieldtype3elemfirstfirst);
5910  hid_t fieldtype3elemfirstsecond=H5Tget_member_type(fieldtype2elemfirst, 1);
5911  unsigned int total_size3elemfirstsecond=H5Tget_size(fieldtype3elemfirstsecond);
5912  hid_t fieldtype2elemsecond=H5Tget_member_type(item_type0, 1);
5913  unsigned int total_size2elemsecond=H5Tget_size(fieldtype2elemsecond);
5914  hsize_t fieldlen2elemsecond;
5915  H5Tget_array_dims2(fieldtype2elemsecond, &fieldlen2elemsecond);
5916  hid_t item_type2elemsecond=H5Tget_super(fieldtype2elemsecond);
5917  hid_t fieldtype3elemsecondkey=H5Tget_member_type(item_type2elemsecond, 0);
5918  unsigned int total_size3elemsecondkey=H5Tget_size(fieldtype3elemsecondkey);
5919  hid_t fieldtype3elemsecondval=H5Tget_member_type(item_type2elemsecond, 1);
5920  unsigned int total_size3elemsecondval=H5Tget_size(fieldtype3elemsecondval);
5921  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
5922  x0=std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>(fieldlen0);
5923  for(unsigned int k0=0;k0<fieldlen0;++k0){
5924  std::pair<std::pair<double, double>, std::map<std::string, double>> x1elem;
5925  std::pair<double, double> x2elemfirst;
5926  double x3elemfirstfirst;
5927  x3elemfirstfirst=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0);
5928  double x3elemfirstsecond;
5929  x3elemfirstsecond=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0+total_size3elemfirstfirst);
5930  x2elemfirst=std::make_pair(x3elemfirstfirst, x3elemfirstsecond);
5931  std::map<std::string, double> x2elemsecond;
5932  for(unsigned int k2elemsecond=0;k2elemsecond<fieldlen2elemsecond;++k2elemsecond){
5933  std::string x3elemsecondkey;
5934  x3elemsecondkey=VLRead<std::string,VL_STRING>(buf+offset+total_size1elem*k0+total_size2elemfirst+(total_size3elemsecondkey+total_size3elemsecondval)*k2elemsecond);
5935  double x3elemsecondval;
5936  x3elemsecondval=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0+total_size2elemfirst+(total_size3elemsecondkey+total_size3elemsecondval)*k2elemsecond+total_size3elemsecondkey);
5937  x2elemsecond[x3elemsecondkey]=x3elemsecondval;
5938 
5939  }
5940  x1elem=std::make_pair(x2elemfirst, x2elemsecond);
5941  x0[k0]=x1elem;
5942 
5943  }
5944  is_row_selected=CmpConds<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>(&x0, &(field_conds[qr.fields[j]]));
5945  if(is_row_selected){
5946  row[j]=x0;
5947 
5948  }
5949  H5Tclose(fieldtype3elemsecondval);
5950  H5Tclose(fieldtype3elemsecondkey);
5951  H5Tclose(item_type2elemsecond);
5952  H5Tclose(fieldtype2elemsecond);
5953  H5Tclose(fieldtype3elemfirstsecond);
5954  H5Tclose(fieldtype3elemfirstfirst);
5955  H5Tclose(fieldtype2elemfirst);
5956  H5Tclose(item_type0);
5957  H5Tclose(fieldtype0);
5958  break;
5959 
5960  }
5962  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
5963  unsigned int total_size0=H5Tget_size(fieldtype0);
5964  hsize_t fieldlen0;
5965  H5Tget_array_dims2(fieldtype0, &fieldlen0);
5966  hid_t item_type0=H5Tget_super(fieldtype0);
5967  unsigned int total_size1elem=H5Tget_size(item_type0);
5968  hid_t fieldtype2elemfirst=H5Tget_member_type(item_type0, 0);
5969  unsigned int total_size2elemfirst=H5Tget_size(fieldtype2elemfirst);
5970  hid_t fieldtype3elemfirstfirst=H5Tget_member_type(fieldtype2elemfirst, 0);
5971  unsigned int total_size3elemfirstfirst=H5Tget_size(fieldtype3elemfirstfirst);
5972  hid_t fieldtype3elemfirstsecond=H5Tget_member_type(fieldtype2elemfirst, 1);
5973  unsigned int total_size3elemfirstsecond=H5Tget_size(fieldtype3elemfirstsecond);
5974  unsigned int total_size2elemsecond=CYCLUS_SHA1_SIZE;
5975  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
5976  x0=std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>(fieldlen0);
5977  for(unsigned int k0=0;k0<fieldlen0;++k0){
5978  std::pair<std::pair<double, double>, std::map<std::string, double>> x1elem;
5979  std::pair<double, double> x2elemfirst;
5980  double x3elemfirstfirst;
5981  x3elemfirstfirst=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0);
5982  double x3elemfirstsecond;
5983  x3elemfirstsecond=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0+total_size3elemfirstfirst);
5984  x2elemfirst=std::make_pair(x3elemfirstfirst, x3elemfirstsecond);
5985  std::map<std::string, double> x2elemsecond;
5986  x2elemsecond=VLRead<std::map<std::string, double>,VL_MAP_STRING_DOUBLE>(buf+offset+total_size1elem*k0+total_size2elemfirst);
5987  x1elem=std::make_pair(x2elemfirst, x2elemsecond);
5988  x0[k0]=x1elem;
5989 
5990  }
5991  is_row_selected=CmpConds<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>(&x0, &(field_conds[qr.fields[j]]));
5992  if(is_row_selected){
5993  row[j]=x0;
5994 
5995  }
5996  H5Tclose(fieldtype3elemfirstsecond);
5997  H5Tclose(fieldtype3elemfirstfirst);
5998  H5Tclose(fieldtype2elemfirst);
5999  H5Tclose(item_type0);
6000  H5Tclose(fieldtype0);
6001  break;
6002 
6003  }
6005  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6006  unsigned int total_size0=H5Tget_size(fieldtype0);
6007  hsize_t fieldlen0;
6008  H5Tget_array_dims2(fieldtype0, &fieldlen0);
6009  hid_t item_type0=H5Tget_super(fieldtype0);
6010  unsigned int total_size1elem=H5Tget_size(item_type0);
6011  hid_t fieldtype2elemfirst=H5Tget_member_type(item_type0, 0);
6012  unsigned int total_size2elemfirst=H5Tget_size(fieldtype2elemfirst);
6013  hid_t fieldtype3elemfirstfirst=H5Tget_member_type(fieldtype2elemfirst, 0);
6014  unsigned int total_size3elemfirstfirst=H5Tget_size(fieldtype3elemfirstfirst);
6015  hid_t fieldtype3elemfirstsecond=H5Tget_member_type(fieldtype2elemfirst, 1);
6016  unsigned int total_size3elemfirstsecond=H5Tget_size(fieldtype3elemfirstsecond);
6017  unsigned int total_size2elemsecond=CYCLUS_SHA1_SIZE;
6018  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
6019  x0=std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>(fieldlen0);
6020  for(unsigned int k0=0;k0<fieldlen0;++k0){
6021  std::pair<std::pair<double, double>, std::map<std::string, double>> x1elem;
6022  std::pair<double, double> x2elemfirst;
6023  double x3elemfirstfirst;
6024  x3elemfirstfirst=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0);
6025  double x3elemfirstsecond;
6026  x3elemfirstsecond=*reinterpret_cast<double*>(buf+offset+total_size1elem*k0+total_size3elemfirstfirst);
6027  x2elemfirst=std::make_pair(x3elemfirstfirst, x3elemfirstsecond);
6028  std::map<std::string, double> x2elemsecond;
6029  x2elemsecond=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(buf+offset+total_size1elem*k0+total_size2elemfirst);
6030  x1elem=std::make_pair(x2elemfirst, x2elemsecond);
6031  x0[k0]=x1elem;
6032 
6033  }
6034  is_row_selected=CmpConds<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>(&x0, &(field_conds[qr.fields[j]]));
6035  if(is_row_selected){
6036  row[j]=x0;
6037 
6038  }
6039  H5Tclose(fieldtype3elemfirstsecond);
6040  H5Tclose(fieldtype3elemfirstfirst);
6041  H5Tclose(fieldtype2elemfirst);
6042  H5Tclose(item_type0);
6043  H5Tclose(fieldtype0);
6044  break;
6045 
6046  }
6048  unsigned int total_size0=CYCLUS_SHA1_SIZE;
6049  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
6050  x0=VLRead<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>,VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(buf+offset);
6051  is_row_selected=CmpConds<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>(&x0, &(field_conds[qr.fields[j]]));
6052  if(is_row_selected){
6053  row[j]=x0;
6054 
6055  }
6056  break;
6057 
6058  }
6060  unsigned int total_size0=CYCLUS_SHA1_SIZE;
6061  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
6062  x0=VLRead<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>,VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(buf+offset);
6063  is_row_selected=CmpConds<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>(&x0, &(field_conds[qr.fields[j]]));
6064  if(is_row_selected){
6065  row[j]=x0;
6066 
6067  }
6068  break;
6069 
6070  }
6072  unsigned int total_size0=CYCLUS_SHA1_SIZE;
6073  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
6074  x0=VLRead<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>,VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(buf+offset);
6075  is_row_selected=CmpConds<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>(&x0, &(field_conds[qr.fields[j]]));
6076  if(is_row_selected){
6077  row[j]=x0;
6078 
6079  }
6080  break;
6081 
6082  }
6084  unsigned int total_size0=CYCLUS_SHA1_SIZE;
6085  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
6086  x0=VLRead<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>,VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(buf+offset);
6087  is_row_selected=CmpConds<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>(&x0, &(field_conds[qr.fields[j]]));
6088  if(is_row_selected){
6089  row[j]=x0;
6090 
6091  }
6092  break;
6093 
6094  }
6096  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6097  unsigned int total_size0=H5Tget_size(fieldtype0);
6098  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6099  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6100  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6101  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6102  size_t nullpos2secondfirst;
6103  hid_t fieldtype2secondfirst=H5Tget_member_type(fieldtype1second, 0);
6104  unsigned int total_size2secondfirst=H5Tget_size(fieldtype2secondfirst);
6105  size_t nullpos2secondsecond;
6106  hid_t fieldtype2secondsecond=H5Tget_member_type(fieldtype1second, 1);
6107  unsigned int total_size2secondsecond=H5Tget_size(fieldtype2secondsecond);
6108  std::pair<int, std::pair<std::string, std::string>> x0;
6109  int x1first;
6110  x1first=*reinterpret_cast<int*>(buf+offset);
6111  std::pair<std::string, std::string> x1second;
6112  std::string x2secondfirst;
6113  x2secondfirst=std::string(buf+offset+total_size1first, total_size2secondfirst);
6114  nullpos2secondfirst=x2secondfirst.find('\0');
6115  if(nullpos2secondfirst!=std::string::npos){
6116  x2secondfirst.resize(nullpos2secondfirst);
6117 
6118  }
6119  std::string x2secondsecond;
6120  x2secondsecond=std::string(buf+offset+total_size1first+total_size2secondfirst, total_size2secondsecond);
6121  nullpos2secondsecond=x2secondsecond.find('\0');
6122  if(nullpos2secondsecond!=std::string::npos){
6123  x2secondsecond.resize(nullpos2secondsecond);
6124 
6125  }
6126  x1second=std::make_pair(x2secondfirst, x2secondsecond);
6127  x0=std::make_pair(x1first, x1second);
6128  is_row_selected=CmpConds<std::pair<int, std::pair<std::string, std::string>>>(&x0, &(field_conds[qr.fields[j]]));
6129  if(is_row_selected){
6130  row[j]=x0;
6131 
6132  }
6133  H5Tclose(fieldtype2secondsecond);
6134  H5Tclose(fieldtype2secondfirst);
6135  H5Tclose(fieldtype1second);
6136  H5Tclose(fieldtype1first);
6137  H5Tclose(fieldtype0);
6138  break;
6139 
6140  }
6142  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6143  unsigned int total_size0=H5Tget_size(fieldtype0);
6144  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6145  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6146  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6147  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6148  hid_t fieldtype2secondfirst=H5Tget_member_type(fieldtype1second, 0);
6149  unsigned int total_size2secondfirst=H5Tget_size(fieldtype2secondfirst);
6150  size_t nullpos2secondsecond;
6151  hid_t fieldtype2secondsecond=H5Tget_member_type(fieldtype1second, 1);
6152  unsigned int total_size2secondsecond=H5Tget_size(fieldtype2secondsecond);
6153  std::pair<int, std::pair<std::string, std::string>> x0;
6154  int x1first;
6155  x1first=*reinterpret_cast<int*>(buf+offset);
6156  std::pair<std::string, std::string> x1second;
6157  std::string x2secondfirst;
6158  x2secondfirst=VLRead<std::string,VL_STRING>(buf+offset+total_size1first);
6159  std::string x2secondsecond;
6160  x2secondsecond=std::string(buf+offset+total_size1first+total_size2secondfirst, total_size2secondsecond);
6161  nullpos2secondsecond=x2secondsecond.find('\0');
6162  if(nullpos2secondsecond!=std::string::npos){
6163  x2secondsecond.resize(nullpos2secondsecond);
6164 
6165  }
6166  x1second=std::make_pair(x2secondfirst, x2secondsecond);
6167  x0=std::make_pair(x1first, x1second);
6168  is_row_selected=CmpConds<std::pair<int, std::pair<std::string, std::string>>>(&x0, &(field_conds[qr.fields[j]]));
6169  if(is_row_selected){
6170  row[j]=x0;
6171 
6172  }
6173  H5Tclose(fieldtype2secondsecond);
6174  H5Tclose(fieldtype2secondfirst);
6175  H5Tclose(fieldtype1second);
6176  H5Tclose(fieldtype1first);
6177  H5Tclose(fieldtype0);
6178  break;
6179 
6180  }
6182  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6183  unsigned int total_size0=H5Tget_size(fieldtype0);
6184  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6185  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6186  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6187  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6188  size_t nullpos2secondfirst;
6189  hid_t fieldtype2secondfirst=H5Tget_member_type(fieldtype1second, 0);
6190  unsigned int total_size2secondfirst=H5Tget_size(fieldtype2secondfirst);
6191  hid_t fieldtype2secondsecond=H5Tget_member_type(fieldtype1second, 1);
6192  unsigned int total_size2secondsecond=H5Tget_size(fieldtype2secondsecond);
6193  std::pair<int, std::pair<std::string, std::string>> x0;
6194  int x1first;
6195  x1first=*reinterpret_cast<int*>(buf+offset);
6196  std::pair<std::string, std::string> x1second;
6197  std::string x2secondfirst;
6198  x2secondfirst=std::string(buf+offset+total_size1first, total_size2secondfirst);
6199  nullpos2secondfirst=x2secondfirst.find('\0');
6200  if(nullpos2secondfirst!=std::string::npos){
6201  x2secondfirst.resize(nullpos2secondfirst);
6202 
6203  }
6204  std::string x2secondsecond;
6205  x2secondsecond=VLRead<std::string,VL_STRING>(buf+offset+total_size1first+total_size2secondfirst);
6206  x1second=std::make_pair(x2secondfirst, x2secondsecond);
6207  x0=std::make_pair(x1first, x1second);
6208  is_row_selected=CmpConds<std::pair<int, std::pair<std::string, std::string>>>(&x0, &(field_conds[qr.fields[j]]));
6209  if(is_row_selected){
6210  row[j]=x0;
6211 
6212  }
6213  H5Tclose(fieldtype2secondsecond);
6214  H5Tclose(fieldtype2secondfirst);
6215  H5Tclose(fieldtype1second);
6216  H5Tclose(fieldtype1first);
6217  H5Tclose(fieldtype0);
6218  break;
6219 
6220  }
6222  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6223  unsigned int total_size0=H5Tget_size(fieldtype0);
6224  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6225  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6226  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6227  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6228  hid_t fieldtype2secondfirst=H5Tget_member_type(fieldtype1second, 0);
6229  unsigned int total_size2secondfirst=H5Tget_size(fieldtype2secondfirst);
6230  hid_t fieldtype2secondsecond=H5Tget_member_type(fieldtype1second, 1);
6231  unsigned int total_size2secondsecond=H5Tget_size(fieldtype2secondsecond);
6232  std::pair<int, std::pair<std::string, std::string>> x0;
6233  int x1first;
6234  x1first=*reinterpret_cast<int*>(buf+offset);
6235  std::pair<std::string, std::string> x1second;
6236  std::string x2secondfirst;
6237  x2secondfirst=VLRead<std::string,VL_STRING>(buf+offset+total_size1first);
6238  std::string x2secondsecond;
6239  x2secondsecond=VLRead<std::string,VL_STRING>(buf+offset+total_size1first+total_size2secondfirst);
6240  x1second=std::make_pair(x2secondfirst, x2secondsecond);
6241  x0=std::make_pair(x1first, x1second);
6242  is_row_selected=CmpConds<std::pair<int, std::pair<std::string, std::string>>>(&x0, &(field_conds[qr.fields[j]]));
6243  if(is_row_selected){
6244  row[j]=x0;
6245 
6246  }
6247  H5Tclose(fieldtype2secondsecond);
6248  H5Tclose(fieldtype2secondfirst);
6249  H5Tclose(fieldtype1second);
6250  H5Tclose(fieldtype1first);
6251  H5Tclose(fieldtype0);
6252  break;
6253 
6254  }
6255  case PAIR_DOUBLE_DOUBLE: {
6256  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6257  unsigned int total_size0=H5Tget_size(fieldtype0);
6258  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6259  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6260  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6261  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6262  std::pair<double, double> x0;
6263  double x1first;
6264  x1first=*reinterpret_cast<double*>(buf+offset);
6265  double x1second;
6266  x1second=*reinterpret_cast<double*>(buf+offset+total_size1first);
6267  x0=std::make_pair(x1first, x1second);
6268  is_row_selected=CmpConds<std::pair<double, double>>(&x0, &(field_conds[qr.fields[j]]));
6269  if(is_row_selected){
6270  row[j]=x0;
6271 
6272  }
6273  H5Tclose(fieldtype1second);
6274  H5Tclose(fieldtype1first);
6275  H5Tclose(fieldtype0);
6276  break;
6277 
6278  }
6280  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6281  unsigned int total_size0=H5Tget_size(fieldtype0);
6282  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6283  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6284  hid_t fieldtype2firstfirst=H5Tget_member_type(fieldtype1first, 0);
6285  unsigned int total_size2firstfirst=H5Tget_size(fieldtype2firstfirst);
6286  hid_t fieldtype2firstsecond=H5Tget_member_type(fieldtype1first, 1);
6287  unsigned int total_size2firstsecond=H5Tget_size(fieldtype2firstsecond);
6288  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6289  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6290  hsize_t fieldlen1second;
6291  H5Tget_array_dims2(fieldtype1second, &fieldlen1second);
6292  hid_t item_type1second=H5Tget_super(fieldtype1second);
6293  size_t nullpos2secondkey;
6294  hid_t fieldtype2secondkey=H5Tget_member_type(item_type1second, 0);
6295  unsigned int total_size2secondkey=H5Tget_size(fieldtype2secondkey);
6296  hid_t fieldtype2secondval=H5Tget_member_type(item_type1second, 1);
6297  unsigned int total_size2secondval=H5Tget_size(fieldtype2secondval);
6298  std::pair<std::pair<double, double>, std::map<std::string, double>> x0;
6299  std::pair<double, double> x1first;
6300  double x2firstfirst;
6301  x2firstfirst=*reinterpret_cast<double*>(buf+offset);
6302  double x2firstsecond;
6303  x2firstsecond=*reinterpret_cast<double*>(buf+offset+total_size2firstfirst);
6304  x1first=std::make_pair(x2firstfirst, x2firstsecond);
6305  std::map<std::string, double> x1second;
6306  for(unsigned int k1second=0;k1second<fieldlen1second;++k1second){
6307  std::string x2secondkey;
6308  x2secondkey=std::string(buf+offset+total_size1first+(total_size2secondkey+total_size2secondval)*k1second, total_size2secondkey);
6309  nullpos2secondkey=x2secondkey.find('\0');
6310  if(nullpos2secondkey!=std::string::npos){
6311  x2secondkey.resize(nullpos2secondkey);
6312 
6313  }
6314  double x2secondval;
6315  x2secondval=*reinterpret_cast<double*>(buf+offset+total_size1first+(total_size2secondkey+total_size2secondval)*k1second+total_size2secondkey);
6316  x1second[x2secondkey]=x2secondval;
6317 
6318  }
6319  x0=std::make_pair(x1first, x1second);
6320  is_row_selected=CmpConds<std::pair<std::pair<double, double>, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
6321  if(is_row_selected){
6322  row[j]=x0;
6323 
6324  }
6325  H5Tclose(fieldtype2secondval);
6326  H5Tclose(fieldtype2secondkey);
6327  H5Tclose(item_type1second);
6328  H5Tclose(fieldtype1second);
6329  H5Tclose(fieldtype2firstsecond);
6330  H5Tclose(fieldtype2firstfirst);
6331  H5Tclose(fieldtype1first);
6332  H5Tclose(fieldtype0);
6333  break;
6334 
6335  }
6337  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6338  unsigned int total_size0=H5Tget_size(fieldtype0);
6339  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);