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);
6340  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6341  hid_t fieldtype2firstfirst=H5Tget_member_type(fieldtype1first, 0);
6342  unsigned int total_size2firstfirst=H5Tget_size(fieldtype2firstfirst);
6343  hid_t fieldtype2firstsecond=H5Tget_member_type(fieldtype1first, 1);
6344  unsigned int total_size2firstsecond=H5Tget_size(fieldtype2firstsecond);
6345  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6346  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6347  hsize_t fieldlen1second;
6348  H5Tget_array_dims2(fieldtype1second, &fieldlen1second);
6349  hid_t item_type1second=H5Tget_super(fieldtype1second);
6350  hid_t fieldtype2secondkey=H5Tget_member_type(item_type1second, 0);
6351  unsigned int total_size2secondkey=H5Tget_size(fieldtype2secondkey);
6352  hid_t fieldtype2secondval=H5Tget_member_type(item_type1second, 1);
6353  unsigned int total_size2secondval=H5Tget_size(fieldtype2secondval);
6354  std::pair<std::pair<double, double>, std::map<std::string, double>> x0;
6355  std::pair<double, double> x1first;
6356  double x2firstfirst;
6357  x2firstfirst=*reinterpret_cast<double*>(buf+offset);
6358  double x2firstsecond;
6359  x2firstsecond=*reinterpret_cast<double*>(buf+offset+total_size2firstfirst);
6360  x1first=std::make_pair(x2firstfirst, x2firstsecond);
6361  std::map<std::string, double> x1second;
6362  for(unsigned int k1second=0;k1second<fieldlen1second;++k1second){
6363  std::string x2secondkey;
6364  x2secondkey=VLRead<std::string,VL_STRING>(buf+offset+total_size1first+(total_size2secondkey+total_size2secondval)*k1second);
6365  double x2secondval;
6366  x2secondval=*reinterpret_cast<double*>(buf+offset+total_size1first+(total_size2secondkey+total_size2secondval)*k1second+total_size2secondkey);
6367  x1second[x2secondkey]=x2secondval;
6368 
6369  }
6370  x0=std::make_pair(x1first, x1second);
6371  is_row_selected=CmpConds<std::pair<std::pair<double, double>, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
6372  if(is_row_selected){
6373  row[j]=x0;
6374 
6375  }
6376  H5Tclose(fieldtype2secondval);
6377  H5Tclose(fieldtype2secondkey);
6378  H5Tclose(item_type1second);
6379  H5Tclose(fieldtype1second);
6380  H5Tclose(fieldtype2firstsecond);
6381  H5Tclose(fieldtype2firstfirst);
6382  H5Tclose(fieldtype1first);
6383  H5Tclose(fieldtype0);
6384  break;
6385 
6386  }
6388  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6389  unsigned int total_size0=H5Tget_size(fieldtype0);
6390  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6391  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6392  hid_t fieldtype2firstfirst=H5Tget_member_type(fieldtype1first, 0);
6393  unsigned int total_size2firstfirst=H5Tget_size(fieldtype2firstfirst);
6394  hid_t fieldtype2firstsecond=H5Tget_member_type(fieldtype1first, 1);
6395  unsigned int total_size2firstsecond=H5Tget_size(fieldtype2firstsecond);
6396  unsigned int total_size1second=CYCLUS_SHA1_SIZE;
6397  std::pair<std::pair<double, double>, std::map<std::string, double>> x0;
6398  std::pair<double, double> x1first;
6399  double x2firstfirst;
6400  x2firstfirst=*reinterpret_cast<double*>(buf+offset);
6401  double x2firstsecond;
6402  x2firstsecond=*reinterpret_cast<double*>(buf+offset+total_size2firstfirst);
6403  x1first=std::make_pair(x2firstfirst, x2firstsecond);
6404  std::map<std::string, double> x1second;
6405  x1second=VLRead<std::map<std::string, double>,VL_MAP_STRING_DOUBLE>(buf+offset+total_size1first);
6406  x0=std::make_pair(x1first, x1second);
6407  is_row_selected=CmpConds<std::pair<std::pair<double, double>, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
6408  if(is_row_selected){
6409  row[j]=x0;
6410 
6411  }
6412  H5Tclose(fieldtype2firstsecond);
6413  H5Tclose(fieldtype2firstfirst);
6414  H5Tclose(fieldtype1first);
6415  H5Tclose(fieldtype0);
6416  break;
6417 
6418  }
6420  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6421  unsigned int total_size0=H5Tget_size(fieldtype0);
6422  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6423  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6424  hid_t fieldtype2firstfirst=H5Tget_member_type(fieldtype1first, 0);
6425  unsigned int total_size2firstfirst=H5Tget_size(fieldtype2firstfirst);
6426  hid_t fieldtype2firstsecond=H5Tget_member_type(fieldtype1first, 1);
6427  unsigned int total_size2firstsecond=H5Tget_size(fieldtype2firstsecond);
6428  unsigned int total_size1second=CYCLUS_SHA1_SIZE;
6429  std::pair<std::pair<double, double>, std::map<std::string, double>> x0;
6430  std::pair<double, double> x1first;
6431  double x2firstfirst;
6432  x2firstfirst=*reinterpret_cast<double*>(buf+offset);
6433  double x2firstsecond;
6434  x2firstsecond=*reinterpret_cast<double*>(buf+offset+total_size2firstfirst);
6435  x1first=std::make_pair(x2firstfirst, x2firstsecond);
6436  std::map<std::string, double> x1second;
6437  x1second=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(buf+offset+total_size1first);
6438  x0=std::make_pair(x1first, x1second);
6439  is_row_selected=CmpConds<std::pair<std::pair<double, double>, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
6440  if(is_row_selected){
6441  row[j]=x0;
6442 
6443  }
6444  H5Tclose(fieldtype2firstsecond);
6445  H5Tclose(fieldtype2firstfirst);
6446  H5Tclose(fieldtype1first);
6447  H5Tclose(fieldtype0);
6448  break;
6449 
6450  }
6452  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6453  unsigned int total_size0=H5Tget_size(fieldtype0);
6454  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6455  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6456  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6457  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6458  hsize_t fieldlen1second;
6459  H5Tget_array_dims2(fieldtype1second, &fieldlen1second);
6460  hid_t item_type1second=H5Tget_super(fieldtype1second);
6461  hid_t fieldtype2secondkey=H5Tget_member_type(item_type1second, 0);
6462  unsigned int total_size2secondkey=H5Tget_size(fieldtype2secondkey);
6463  hid_t fieldtype2secondval=H5Tget_member_type(item_type1second, 1);
6464  unsigned int total_size2secondval=H5Tget_size(fieldtype2secondval);
6465  std::pair<double, std::map<int, double>> x0;
6466  double x1first;
6467  x1first=*reinterpret_cast<double*>(buf+offset);
6468  std::map<int, double> x1second;
6469  for(unsigned int k1second=0;k1second<fieldlen1second;++k1second){
6470  int x2secondkey;
6471  x2secondkey=*reinterpret_cast<int*>(buf+offset+total_size1first+(total_size2secondkey+total_size2secondval)*k1second);
6472  double x2secondval;
6473  x2secondval=*reinterpret_cast<double*>(buf+offset+total_size1first+(total_size2secondkey+total_size2secondval)*k1second+total_size2secondkey);
6474  x1second[x2secondkey]=x2secondval;
6475 
6476  }
6477  x0=std::make_pair(x1first, x1second);
6478  is_row_selected=CmpConds<std::pair<double, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
6479  if(is_row_selected){
6480  row[j]=x0;
6481 
6482  }
6483  H5Tclose(fieldtype2secondval);
6484  H5Tclose(fieldtype2secondkey);
6485  H5Tclose(item_type1second);
6486  H5Tclose(fieldtype1second);
6487  H5Tclose(fieldtype1first);
6488  H5Tclose(fieldtype0);
6489  break;
6490 
6491  }
6493  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6494  unsigned int total_size0=H5Tget_size(fieldtype0);
6495  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6496  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6497  unsigned int total_size1second=CYCLUS_SHA1_SIZE;
6498  std::pair<double, std::map<int, double>> x0;
6499  double x1first;
6500  x1first=*reinterpret_cast<double*>(buf+offset);
6501  std::map<int, double> x1second;
6502  x1second=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(buf+offset+total_size1first);
6503  x0=std::make_pair(x1first, x1second);
6504  is_row_selected=CmpConds<std::pair<double, std::map<int, double>>>(&x0, &(field_conds[qr.fields[j]]));
6505  if(is_row_selected){
6506  row[j]=x0;
6507 
6508  }
6509  H5Tclose(fieldtype1first);
6510  H5Tclose(fieldtype0);
6511  break;
6512 
6513  }
6515  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6516  unsigned int total_size0=H5Tget_size(fieldtype0);
6517  hsize_t fieldlen0;
6518  H5Tget_array_dims2(fieldtype0, &fieldlen0);
6519  hid_t item_type0=H5Tget_super(fieldtype0);
6520  unsigned int total_size1elem=H5Tget_size(item_type0);
6521  hid_t fieldtype2elemfirst=H5Tget_member_type(item_type0, 0);
6522  unsigned int total_size2elemfirst=H5Tget_size(fieldtype2elemfirst);
6523  hid_t fieldtype2elemsecond=H5Tget_member_type(item_type0, 1);
6524  unsigned int total_size2elemsecond=H5Tget_size(fieldtype2elemsecond);
6525  size_t nullpos3elemsecondfirst;
6526  hid_t fieldtype3elemsecondfirst=H5Tget_member_type(fieldtype2elemsecond, 0);
6527  unsigned int total_size3elemsecondfirst=H5Tget_size(fieldtype3elemsecondfirst);
6528  size_t nullpos3elemsecondsecond;
6529  hid_t fieldtype3elemsecondsecond=H5Tget_member_type(fieldtype2elemsecond, 1);
6530  unsigned int total_size3elemsecondsecond=H5Tget_size(fieldtype3elemsecondsecond);
6531  std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
6532  x0=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen0);
6533  for(unsigned int k0=0;k0<fieldlen0;++k0){
6534  std::pair<int, std::pair<std::string, std::string>> x1elem;
6535  int x2elemfirst;
6536  x2elemfirst=*reinterpret_cast<int*>(buf+offset+total_size1elem*k0);
6537  std::pair<std::string, std::string> x2elemsecond;
6538  std::string x3elemsecondfirst;
6539  x3elemsecondfirst=std::string(buf+offset+total_size1elem*k0+total_size2elemfirst, total_size3elemsecondfirst);
6540  nullpos3elemsecondfirst=x3elemsecondfirst.find('\0');
6541  if(nullpos3elemsecondfirst!=std::string::npos){
6542  x3elemsecondfirst.resize(nullpos3elemsecondfirst);
6543 
6544  }
6545  std::string x3elemsecondsecond;
6546  x3elemsecondsecond=std::string(buf+offset+total_size1elem*k0+total_size2elemfirst+total_size3elemsecondfirst, total_size3elemsecondsecond);
6547  nullpos3elemsecondsecond=x3elemsecondsecond.find('\0');
6548  if(nullpos3elemsecondsecond!=std::string::npos){
6549  x3elemsecondsecond.resize(nullpos3elemsecondsecond);
6550 
6551  }
6552  x2elemsecond=std::make_pair(x3elemsecondfirst, x3elemsecondsecond);
6553  x1elem=std::make_pair(x2elemfirst, x2elemsecond);
6554  x0[k0]=x1elem;
6555 
6556  }
6557  is_row_selected=CmpConds<std::vector<std::pair<int, std::pair<std::string, std::string>>>>(&x0, &(field_conds[qr.fields[j]]));
6558  if(is_row_selected){
6559  row[j]=x0;
6560 
6561  }
6562  H5Tclose(fieldtype3elemsecondsecond);
6563  H5Tclose(fieldtype3elemsecondfirst);
6564  H5Tclose(fieldtype2elemsecond);
6565  H5Tclose(fieldtype2elemfirst);
6566  H5Tclose(item_type0);
6567  H5Tclose(fieldtype0);
6568  break;
6569 
6570  }
6572  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6573  unsigned int total_size0=H5Tget_size(fieldtype0);
6574  hsize_t fieldlen0;
6575  H5Tget_array_dims2(fieldtype0, &fieldlen0);
6576  hid_t item_type0=H5Tget_super(fieldtype0);
6577  unsigned int total_size1elem=H5Tget_size(item_type0);
6578  hid_t fieldtype2elemfirst=H5Tget_member_type(item_type0, 0);
6579  unsigned int total_size2elemfirst=H5Tget_size(fieldtype2elemfirst);
6580  hid_t fieldtype2elemsecond=H5Tget_member_type(item_type0, 1);
6581  unsigned int total_size2elemsecond=H5Tget_size(fieldtype2elemsecond);
6582  hid_t fieldtype3elemsecondfirst=H5Tget_member_type(fieldtype2elemsecond, 0);
6583  unsigned int total_size3elemsecondfirst=H5Tget_size(fieldtype3elemsecondfirst);
6584  size_t nullpos3elemsecondsecond;
6585  hid_t fieldtype3elemsecondsecond=H5Tget_member_type(fieldtype2elemsecond, 1);
6586  unsigned int total_size3elemsecondsecond=H5Tget_size(fieldtype3elemsecondsecond);
6587  std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
6588  x0=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen0);
6589  for(unsigned int k0=0;k0<fieldlen0;++k0){
6590  std::pair<int, std::pair<std::string, std::string>> x1elem;
6591  int x2elemfirst;
6592  x2elemfirst=*reinterpret_cast<int*>(buf+offset+total_size1elem*k0);
6593  std::pair<std::string, std::string> x2elemsecond;
6594  std::string x3elemsecondfirst;
6595  x3elemsecondfirst=VLRead<std::string,VL_STRING>(buf+offset+total_size1elem*k0+total_size2elemfirst);
6596  std::string x3elemsecondsecond;
6597  x3elemsecondsecond=std::string(buf+offset+total_size1elem*k0+total_size2elemfirst+total_size3elemsecondfirst, total_size3elemsecondsecond);
6598  nullpos3elemsecondsecond=x3elemsecondsecond.find('\0');
6599  if(nullpos3elemsecondsecond!=std::string::npos){
6600  x3elemsecondsecond.resize(nullpos3elemsecondsecond);
6601 
6602  }
6603  x2elemsecond=std::make_pair(x3elemsecondfirst, x3elemsecondsecond);
6604  x1elem=std::make_pair(x2elemfirst, x2elemsecond);
6605  x0[k0]=x1elem;
6606 
6607  }
6608  is_row_selected=CmpConds<std::vector<std::pair<int, std::pair<std::string, std::string>>>>(&x0, &(field_conds[qr.fields[j]]));
6609  if(is_row_selected){
6610  row[j]=x0;
6611 
6612  }
6613  H5Tclose(fieldtype3elemsecondsecond);
6614  H5Tclose(fieldtype3elemsecondfirst);
6615  H5Tclose(fieldtype2elemsecond);
6616  H5Tclose(fieldtype2elemfirst);
6617  H5Tclose(item_type0);
6618  H5Tclose(fieldtype0);
6619  break;
6620 
6621  }
6623  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6624  unsigned int total_size0=H5Tget_size(fieldtype0);
6625  hsize_t fieldlen0;
6626  H5Tget_array_dims2(fieldtype0, &fieldlen0);
6627  hid_t item_type0=H5Tget_super(fieldtype0);
6628  unsigned int total_size1elem=H5Tget_size(item_type0);
6629  hid_t fieldtype2elemfirst=H5Tget_member_type(item_type0, 0);
6630  unsigned int total_size2elemfirst=H5Tget_size(fieldtype2elemfirst);
6631  hid_t fieldtype2elemsecond=H5Tget_member_type(item_type0, 1);
6632  unsigned int total_size2elemsecond=H5Tget_size(fieldtype2elemsecond);
6633  size_t nullpos3elemsecondfirst;
6634  hid_t fieldtype3elemsecondfirst=H5Tget_member_type(fieldtype2elemsecond, 0);
6635  unsigned int total_size3elemsecondfirst=H5Tget_size(fieldtype3elemsecondfirst);
6636  hid_t fieldtype3elemsecondsecond=H5Tget_member_type(fieldtype2elemsecond, 1);
6637  unsigned int total_size3elemsecondsecond=H5Tget_size(fieldtype3elemsecondsecond);
6638  std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
6639  x0=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen0);
6640  for(unsigned int k0=0;k0<fieldlen0;++k0){
6641  std::pair<int, std::pair<std::string, std::string>> x1elem;
6642  int x2elemfirst;
6643  x2elemfirst=*reinterpret_cast<int*>(buf+offset+total_size1elem*k0);
6644  std::pair<std::string, std::string> x2elemsecond;
6645  std::string x3elemsecondfirst;
6646  x3elemsecondfirst=std::string(buf+offset+total_size1elem*k0+total_size2elemfirst, total_size3elemsecondfirst);
6647  nullpos3elemsecondfirst=x3elemsecondfirst.find('\0');
6648  if(nullpos3elemsecondfirst!=std::string::npos){
6649  x3elemsecondfirst.resize(nullpos3elemsecondfirst);
6650 
6651  }
6652  std::string x3elemsecondsecond;
6653  x3elemsecondsecond=VLRead<std::string,VL_STRING>(buf+offset+total_size1elem*k0+total_size2elemfirst+total_size3elemsecondfirst);
6654  x2elemsecond=std::make_pair(x3elemsecondfirst, x3elemsecondsecond);
6655  x1elem=std::make_pair(x2elemfirst, x2elemsecond);
6656  x0[k0]=x1elem;
6657 
6658  }
6659  is_row_selected=CmpConds<std::vector<std::pair<int, std::pair<std::string, std::string>>>>(&x0, &(field_conds[qr.fields[j]]));
6660  if(is_row_selected){
6661  row[j]=x0;
6662 
6663  }
6664  H5Tclose(fieldtype3elemsecondsecond);
6665  H5Tclose(fieldtype3elemsecondfirst);
6666  H5Tclose(fieldtype2elemsecond);
6667  H5Tclose(fieldtype2elemfirst);
6668  H5Tclose(item_type0);
6669  H5Tclose(fieldtype0);
6670  break;
6671 
6672  }
6674  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6675  unsigned int total_size0=H5Tget_size(fieldtype0);
6676  hsize_t fieldlen0;
6677  H5Tget_array_dims2(fieldtype0, &fieldlen0);
6678  hid_t item_type0=H5Tget_super(fieldtype0);
6679  unsigned int total_size1elem=H5Tget_size(item_type0);
6680  hid_t fieldtype2elemfirst=H5Tget_member_type(item_type0, 0);
6681  unsigned int total_size2elemfirst=H5Tget_size(fieldtype2elemfirst);
6682  hid_t fieldtype2elemsecond=H5Tget_member_type(item_type0, 1);
6683  unsigned int total_size2elemsecond=H5Tget_size(fieldtype2elemsecond);
6684  hid_t fieldtype3elemsecondfirst=H5Tget_member_type(fieldtype2elemsecond, 0);
6685  unsigned int total_size3elemsecondfirst=H5Tget_size(fieldtype3elemsecondfirst);
6686  hid_t fieldtype3elemsecondsecond=H5Tget_member_type(fieldtype2elemsecond, 1);
6687  unsigned int total_size3elemsecondsecond=H5Tget_size(fieldtype3elemsecondsecond);
6688  std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
6689  x0=std::vector<std::pair<int, std::pair<std::string, std::string>>>(fieldlen0);
6690  for(unsigned int k0=0;k0<fieldlen0;++k0){
6691  std::pair<int, std::pair<std::string, std::string>> x1elem;
6692  int x2elemfirst;
6693  x2elemfirst=*reinterpret_cast<int*>(buf+offset+total_size1elem*k0);
6694  std::pair<std::string, std::string> x2elemsecond;
6695  std::string x3elemsecondfirst;
6696  x3elemsecondfirst=VLRead<std::string,VL_STRING>(buf+offset+total_size1elem*k0+total_size2elemfirst);
6697  std::string x3elemsecondsecond;
6698  x3elemsecondsecond=VLRead<std::string,VL_STRING>(buf+offset+total_size1elem*k0+total_size2elemfirst+total_size3elemsecondfirst);
6699  x2elemsecond=std::make_pair(x3elemsecondfirst, x3elemsecondsecond);
6700  x1elem=std::make_pair(x2elemfirst, x2elemsecond);
6701  x0[k0]=x1elem;
6702 
6703  }
6704  is_row_selected=CmpConds<std::vector<std::pair<int, std::pair<std::string, std::string>>>>(&x0, &(field_conds[qr.fields[j]]));
6705  if(is_row_selected){
6706  row[j]=x0;
6707 
6708  }
6709  H5Tclose(fieldtype3elemsecondsecond);
6710  H5Tclose(fieldtype3elemsecondfirst);
6711  H5Tclose(fieldtype2elemsecond);
6712  H5Tclose(fieldtype2elemfirst);
6713  H5Tclose(item_type0);
6714  H5Tclose(fieldtype0);
6715  break;
6716 
6717  }
6719  unsigned int total_size0=CYCLUS_SHA1_SIZE;
6720  std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
6721  x0=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset);
6722  is_row_selected=CmpConds<std::vector<std::pair<int, std::pair<std::string, std::string>>>>(&x0, &(field_conds[qr.fields[j]]));
6723  if(is_row_selected){
6724  row[j]=x0;
6725 
6726  }
6727  break;
6728 
6729  }
6731  unsigned int total_size0=CYCLUS_SHA1_SIZE;
6732  std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
6733  x0=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset);
6734  is_row_selected=CmpConds<std::vector<std::pair<int, std::pair<std::string, std::string>>>>(&x0, &(field_conds[qr.fields[j]]));
6735  if(is_row_selected){
6736  row[j]=x0;
6737 
6738  }
6739  break;
6740 
6741  }
6743  unsigned int total_size0=CYCLUS_SHA1_SIZE;
6744  std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
6745  x0=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset);
6746  is_row_selected=CmpConds<std::vector<std::pair<int, std::pair<std::string, std::string>>>>(&x0, &(field_conds[qr.fields[j]]));
6747  if(is_row_selected){
6748  row[j]=x0;
6749 
6750  }
6751  break;
6752 
6753  }
6755  unsigned int total_size0=CYCLUS_SHA1_SIZE;
6756  std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
6757  x0=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset);
6758  is_row_selected=CmpConds<std::vector<std::pair<int, std::pair<std::string, std::string>>>>(&x0, &(field_conds[qr.fields[j]]));
6759  if(is_row_selected){
6760  row[j]=x0;
6761 
6762  }
6763  break;
6764 
6765  }
6767  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6768  unsigned int total_size0=H5Tget_size(fieldtype0);
6769  size_t nullpos1first;
6770  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6771  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6772  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6773  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6774  hsize_t fieldlen1second;
6775  H5Tget_array_dims2(fieldtype1second, &fieldlen1second);
6776  hid_t item_type1second=H5Tget_super(fieldtype1second);
6777  unsigned int total_size2secondelem=H5Tget_size(item_type1second);
6778  std::pair<std::string, std::vector<double>> x0;
6779  std::string x1first;
6780  x1first=std::string(buf+offset, total_size1first);
6781  nullpos1first=x1first.find('\0');
6782  if(nullpos1first!=std::string::npos){
6783  x1first.resize(nullpos1first);
6784 
6785  }
6786  std::vector<double> x1second;
6787  x1second=std::vector<double>(fieldlen1second);
6788  memcpy(&x1second[0], buf+offset+total_size1first, total_size1second);
6789  x0=std::make_pair(x1first, x1second);
6790  is_row_selected=CmpConds<std::pair<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
6791  if(is_row_selected){
6792  row[j]=x0;
6793 
6794  }
6795  H5Tclose(item_type1second);
6796  H5Tclose(fieldtype1second);
6797  H5Tclose(fieldtype1first);
6798  H5Tclose(fieldtype0);
6799  break;
6800 
6801  }
6803  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6804  unsigned int total_size0=H5Tget_size(fieldtype0);
6805  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6806  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6807  hid_t fieldtype1second=H5Tget_member_type(fieldtype0, 1);
6808  unsigned int total_size1second=H5Tget_size(fieldtype1second);
6809  hsize_t fieldlen1second;
6810  H5Tget_array_dims2(fieldtype1second, &fieldlen1second);
6811  hid_t item_type1second=H5Tget_super(fieldtype1second);
6812  unsigned int total_size2secondelem=H5Tget_size(item_type1second);
6813  std::pair<std::string, std::vector<double>> x0;
6814  std::string x1first;
6815  x1first=VLRead<std::string,VL_STRING>(buf+offset);
6816  std::vector<double> x1second;
6817  x1second=std::vector<double>(fieldlen1second);
6818  memcpy(&x1second[0], buf+offset+total_size1first, total_size1second);
6819  x0=std::make_pair(x1first, x1second);
6820  is_row_selected=CmpConds<std::pair<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
6821  if(is_row_selected){
6822  row[j]=x0;
6823 
6824  }
6825  H5Tclose(item_type1second);
6826  H5Tclose(fieldtype1second);
6827  H5Tclose(fieldtype1first);
6828  H5Tclose(fieldtype0);
6829  break;
6830 
6831  }
6833  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6834  unsigned int total_size0=H5Tget_size(fieldtype0);
6835  size_t nullpos1first;
6836  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6837  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6838  unsigned int total_size1second=CYCLUS_SHA1_SIZE;
6839  std::pair<std::string, std::vector<double>> x0;
6840  std::string x1first;
6841  x1first=std::string(buf+offset, total_size1first);
6842  nullpos1first=x1first.find('\0');
6843  if(nullpos1first!=std::string::npos){
6844  x1first.resize(nullpos1first);
6845 
6846  }
6847  std::vector<double> x1second;
6848  x1second=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(buf+offset+total_size1first);
6849  x0=std::make_pair(x1first, x1second);
6850  is_row_selected=CmpConds<std::pair<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
6851  if(is_row_selected){
6852  row[j]=x0;
6853 
6854  }
6855  H5Tclose(fieldtype1first);
6856  H5Tclose(fieldtype0);
6857  break;
6858 
6859  }
6861  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6862  unsigned int total_size0=H5Tget_size(fieldtype0);
6863  hid_t fieldtype1first=H5Tget_member_type(fieldtype0, 0);
6864  unsigned int total_size1first=H5Tget_size(fieldtype1first);
6865  unsigned int total_size1second=CYCLUS_SHA1_SIZE;
6866  std::pair<std::string, std::vector<double>> x0;
6867  std::string x1first;
6868  x1first=VLRead<std::string,VL_STRING>(buf+offset);
6869  std::vector<double> x1second;
6870  x1second=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(buf+offset+total_size1first);
6871  x0=std::make_pair(x1first, x1second);
6872  is_row_selected=CmpConds<std::pair<std::string, std::vector<double>>>(&x0, &(field_conds[qr.fields[j]]));
6873  if(is_row_selected){
6874  row[j]=x0;
6875 
6876  }
6877  H5Tclose(fieldtype1first);
6878  H5Tclose(fieldtype0);
6879  break;
6880 
6881  }
6883  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6884  unsigned int total_size0=H5Tget_size(fieldtype0);
6885  hsize_t fieldlen0;
6886  H5Tget_array_dims2(fieldtype0, &fieldlen0);
6887  hid_t item_type0=H5Tget_super(fieldtype0);
6888  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
6889  unsigned int total_size1key=H5Tget_size(fieldtype1key);
6890  size_t nullpos2keyfirst;
6891  hid_t fieldtype2keyfirst=H5Tget_member_type(fieldtype1key, 0);
6892  unsigned int total_size2keyfirst=H5Tget_size(fieldtype2keyfirst);
6893  size_t nullpos2keysecond;
6894  hid_t fieldtype2keysecond=H5Tget_member_type(fieldtype1key, 1);
6895  unsigned int total_size2keysecond=H5Tget_size(fieldtype2keysecond);
6896  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
6897  unsigned int total_size1val=H5Tget_size(fieldtype1val);
6898  std::map<std::pair<std::string, std::string>, int> x0;
6899  for(unsigned int k0=0;k0<fieldlen0;++k0){
6900  std::pair<std::string, std::string> x1key;
6901  std::string x2keyfirst;
6902  x2keyfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size2keyfirst);
6903  nullpos2keyfirst=x2keyfirst.find('\0');
6904  if(nullpos2keyfirst!=std::string::npos){
6905  x2keyfirst.resize(nullpos2keyfirst);
6906 
6907  }
6908  std::string x2keysecond;
6909  x2keysecond=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size2keyfirst, total_size2keysecond);
6910  nullpos2keysecond=x2keysecond.find('\0');
6911  if(nullpos2keysecond!=std::string::npos){
6912  x2keysecond.resize(nullpos2keysecond);
6913 
6914  }
6915  x1key=std::make_pair(x2keyfirst, x2keysecond);
6916  int x1val;
6917  x1val=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
6918  x0[x1key]=x1val;
6919 
6920  }
6921  is_row_selected=CmpConds<std::map<std::pair<std::string, std::string>, int>>(&x0, &(field_conds[qr.fields[j]]));
6922  if(is_row_selected){
6923  row[j]=x0;
6924 
6925  }
6926  H5Tclose(fieldtype1val);
6927  H5Tclose(fieldtype2keysecond);
6928  H5Tclose(fieldtype2keyfirst);
6929  H5Tclose(fieldtype1key);
6930  H5Tclose(item_type0);
6931  H5Tclose(fieldtype0);
6932  break;
6933 
6934  }
6936  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6937  unsigned int total_size0=H5Tget_size(fieldtype0);
6938  hsize_t fieldlen0;
6939  H5Tget_array_dims2(fieldtype0, &fieldlen0);
6940  hid_t item_type0=H5Tget_super(fieldtype0);
6941  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
6942  unsigned int total_size1key=H5Tget_size(fieldtype1key);
6943  size_t nullpos2keyfirst;
6944  hid_t fieldtype2keyfirst=H5Tget_member_type(fieldtype1key, 0);
6945  unsigned int total_size2keyfirst=H5Tget_size(fieldtype2keyfirst);
6946  hid_t fieldtype2keysecond=H5Tget_member_type(fieldtype1key, 1);
6947  unsigned int total_size2keysecond=H5Tget_size(fieldtype2keysecond);
6948  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
6949  unsigned int total_size1val=H5Tget_size(fieldtype1val);
6950  std::map<std::pair<std::string, std::string>, int> x0;
6951  for(unsigned int k0=0;k0<fieldlen0;++k0){
6952  std::pair<std::string, std::string> x1key;
6953  std::string x2keyfirst;
6954  x2keyfirst=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size2keyfirst);
6955  nullpos2keyfirst=x2keyfirst.find('\0');
6956  if(nullpos2keyfirst!=std::string::npos){
6957  x2keyfirst.resize(nullpos2keyfirst);
6958 
6959  }
6960  std::string x2keysecond;
6961  x2keysecond=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size2keyfirst);
6962  x1key=std::make_pair(x2keyfirst, x2keysecond);
6963  int x1val;
6964  x1val=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
6965  x0[x1key]=x1val;
6966 
6967  }
6968  is_row_selected=CmpConds<std::map<std::pair<std::string, std::string>, int>>(&x0, &(field_conds[qr.fields[j]]));
6969  if(is_row_selected){
6970  row[j]=x0;
6971 
6972  }
6973  H5Tclose(fieldtype1val);
6974  H5Tclose(fieldtype2keysecond);
6975  H5Tclose(fieldtype2keyfirst);
6976  H5Tclose(fieldtype1key);
6977  H5Tclose(item_type0);
6978  H5Tclose(fieldtype0);
6979  break;
6980 
6981  }
6983  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
6984  unsigned int total_size0=H5Tget_size(fieldtype0);
6985  hsize_t fieldlen0;
6986  H5Tget_array_dims2(fieldtype0, &fieldlen0);
6987  hid_t item_type0=H5Tget_super(fieldtype0);
6988  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
6989  unsigned int total_size1key=H5Tget_size(fieldtype1key);
6990  hid_t fieldtype2keyfirst=H5Tget_member_type(fieldtype1key, 0);
6991  unsigned int total_size2keyfirst=H5Tget_size(fieldtype2keyfirst);
6992  size_t nullpos2keysecond;
6993  hid_t fieldtype2keysecond=H5Tget_member_type(fieldtype1key, 1);
6994  unsigned int total_size2keysecond=H5Tget_size(fieldtype2keysecond);
6995  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
6996  unsigned int total_size1val=H5Tget_size(fieldtype1val);
6997  std::map<std::pair<std::string, std::string>, int> x0;
6998  for(unsigned int k0=0;k0<fieldlen0;++k0){
6999  std::pair<std::string, std::string> x1key;
7000  std::string x2keyfirst;
7001  x2keyfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
7002  std::string x2keysecond;
7003  x2keysecond=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size2keyfirst, total_size2keysecond);
7004  nullpos2keysecond=x2keysecond.find('\0');
7005  if(nullpos2keysecond!=std::string::npos){
7006  x2keysecond.resize(nullpos2keysecond);
7007 
7008  }
7009  x1key=std::make_pair(x2keyfirst, x2keysecond);
7010  int x1val;
7011  x1val=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
7012  x0[x1key]=x1val;
7013 
7014  }
7015  is_row_selected=CmpConds<std::map<std::pair<std::string, std::string>, int>>(&x0, &(field_conds[qr.fields[j]]));
7016  if(is_row_selected){
7017  row[j]=x0;
7018 
7019  }
7020  H5Tclose(fieldtype1val);
7021  H5Tclose(fieldtype2keysecond);
7022  H5Tclose(fieldtype2keyfirst);
7023  H5Tclose(fieldtype1key);
7024  H5Tclose(item_type0);
7025  H5Tclose(fieldtype0);
7026  break;
7027 
7028  }
7030  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
7031  unsigned int total_size0=H5Tget_size(fieldtype0);
7032  hsize_t fieldlen0;
7033  H5Tget_array_dims2(fieldtype0, &fieldlen0);
7034  hid_t item_type0=H5Tget_super(fieldtype0);
7035  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
7036  unsigned int total_size1key=H5Tget_size(fieldtype1key);
7037  hid_t fieldtype2keyfirst=H5Tget_member_type(fieldtype1key, 0);
7038  unsigned int total_size2keyfirst=H5Tget_size(fieldtype2keyfirst);
7039  hid_t fieldtype2keysecond=H5Tget_member_type(fieldtype1key, 1);
7040  unsigned int total_size2keysecond=H5Tget_size(fieldtype2keysecond);
7041  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
7042  unsigned int total_size1val=H5Tget_size(fieldtype1val);
7043  std::map<std::pair<std::string, std::string>, int> x0;
7044  for(unsigned int k0=0;k0<fieldlen0;++k0){
7045  std::pair<std::string, std::string> x1key;
7046  std::string x2keyfirst;
7047  x2keyfirst=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
7048  std::string x2keysecond;
7049  x2keysecond=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size2keyfirst);
7050  x1key=std::make_pair(x2keyfirst, x2keysecond);
7051  int x1val;
7052  x1val=*reinterpret_cast<int*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
7053  x0[x1key]=x1val;
7054 
7055  }
7056  is_row_selected=CmpConds<std::map<std::pair<std::string, std::string>, int>>(&x0, &(field_conds[qr.fields[j]]));
7057  if(is_row_selected){
7058  row[j]=x0;
7059 
7060  }
7061  H5Tclose(fieldtype1val);
7062  H5Tclose(fieldtype2keysecond);
7063  H5Tclose(fieldtype2keyfirst);
7064  H5Tclose(fieldtype1key);
7065  H5Tclose(item_type0);
7066  H5Tclose(fieldtype0);
7067  break;
7068 
7069  }
7071  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7072  std::map<std::pair<std::string, std::string>, int> x0;
7073  x0=VLRead<std::map<std::pair<std::string, std::string>, int>,VL_MAP_PAIR_STRING_STRING_INT>(buf+offset);
7074  is_row_selected=CmpConds<std::map<std::pair<std::string, std::string>, int>>(&x0, &(field_conds[qr.fields[j]]));
7075  if(is_row_selected){
7076  row[j]=x0;
7077 
7078  }
7079  break;
7080 
7081  }
7083  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7084  std::map<std::pair<std::string, std::string>, int> x0;
7085  x0=VLRead<std::map<std::pair<std::string, std::string>, int>,VL_MAP_PAIR_STRING_VL_STRING_INT>(buf+offset);
7086  is_row_selected=CmpConds<std::map<std::pair<std::string, std::string>, int>>(&x0, &(field_conds[qr.fields[j]]));
7087  if(is_row_selected){
7088  row[j]=x0;
7089 
7090  }
7091  break;
7092 
7093  }
7095  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7096  std::map<std::pair<std::string, std::string>, int> x0;
7097  x0=VLRead<std::map<std::pair<std::string, std::string>, int>,VL_MAP_PAIR_VL_STRING_STRING_INT>(buf+offset);
7098  is_row_selected=CmpConds<std::map<std::pair<std::string, std::string>, int>>(&x0, &(field_conds[qr.fields[j]]));
7099  if(is_row_selected){
7100  row[j]=x0;
7101 
7102  }
7103  break;
7104 
7105  }
7107  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7108  std::map<std::pair<std::string, std::string>, int> x0;
7109  x0=VLRead<std::map<std::pair<std::string, std::string>, int>,VL_MAP_PAIR_VL_STRING_VL_STRING_INT>(buf+offset);
7110  is_row_selected=CmpConds<std::map<std::pair<std::string, std::string>, int>>(&x0, &(field_conds[qr.fields[j]]));
7111  if(is_row_selected){
7112  row[j]=x0;
7113 
7114  }
7115  break;
7116 
7117  }
7119  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
7120  unsigned int total_size0=H5Tget_size(fieldtype0);
7121  hsize_t fieldlen0;
7122  H5Tget_array_dims2(fieldtype0, &fieldlen0);
7123  hid_t item_type0=H5Tget_super(fieldtype0);
7124  size_t nullpos1key;
7125  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
7126  unsigned int total_size1key=H5Tget_size(fieldtype1key);
7127  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
7128  unsigned int total_size1val=H5Tget_size(fieldtype1val);
7129  hsize_t fieldlen1val;
7130  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
7131  hid_t item_type1val=H5Tget_super(fieldtype1val);
7132  size_t nullpos2valkey;
7133  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
7134  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
7135  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
7136  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
7137  std::map<std::string, std::map<std::string, double>> x0;
7138  for(unsigned int k0=0;k0<fieldlen0;++k0){
7139  std::string x1key;
7140  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
7141  nullpos1key=x1key.find('\0');
7142  if(nullpos1key!=std::string::npos){
7143  x1key.resize(nullpos1key);
7144 
7145  }
7146  std::map<std::string, double> x1val;
7147  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
7148  std::string x2valkey;
7149  x2valkey=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val, total_size2valkey);
7150  nullpos2valkey=x2valkey.find('\0');
7151  if(nullpos2valkey!=std::string::npos){
7152  x2valkey.resize(nullpos2valkey);
7153 
7154  }
7155  double x2valval;
7156  x2valval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
7157  x1val[x2valkey]=x2valval;
7158 
7159  }
7160  x0[x1key]=x1val;
7161 
7162  }
7163  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7164  if(is_row_selected){
7165  row[j]=x0;
7166 
7167  }
7168  H5Tclose(fieldtype2valval);
7169  H5Tclose(fieldtype2valkey);
7170  H5Tclose(item_type1val);
7171  H5Tclose(fieldtype1val);
7172  H5Tclose(fieldtype1key);
7173  H5Tclose(item_type0);
7174  H5Tclose(fieldtype0);
7175  break;
7176 
7177  }
7179  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
7180  unsigned int total_size0=H5Tget_size(fieldtype0);
7181  hsize_t fieldlen0;
7182  H5Tget_array_dims2(fieldtype0, &fieldlen0);
7183  hid_t item_type0=H5Tget_super(fieldtype0);
7184  size_t nullpos1key;
7185  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
7186  unsigned int total_size1key=H5Tget_size(fieldtype1key);
7187  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
7188  unsigned int total_size1val=H5Tget_size(fieldtype1val);
7189  hsize_t fieldlen1val;
7190  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
7191  hid_t item_type1val=H5Tget_super(fieldtype1val);
7192  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
7193  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
7194  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
7195  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
7196  std::map<std::string, std::map<std::string, double>> x0;
7197  for(unsigned int k0=0;k0<fieldlen0;++k0){
7198  std::string x1key;
7199  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
7200  nullpos1key=x1key.find('\0');
7201  if(nullpos1key!=std::string::npos){
7202  x1key.resize(nullpos1key);
7203 
7204  }
7205  std::map<std::string, double> x1val;
7206  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
7207  std::string x2valkey;
7208  x2valkey=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val);
7209  double x2valval;
7210  x2valval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
7211  x1val[x2valkey]=x2valval;
7212 
7213  }
7214  x0[x1key]=x1val;
7215 
7216  }
7217  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7218  if(is_row_selected){
7219  row[j]=x0;
7220 
7221  }
7222  H5Tclose(fieldtype2valval);
7223  H5Tclose(fieldtype2valkey);
7224  H5Tclose(item_type1val);
7225  H5Tclose(fieldtype1val);
7226  H5Tclose(fieldtype1key);
7227  H5Tclose(item_type0);
7228  H5Tclose(fieldtype0);
7229  break;
7230 
7231  }
7233  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
7234  unsigned int total_size0=H5Tget_size(fieldtype0);
7235  hsize_t fieldlen0;
7236  H5Tget_array_dims2(fieldtype0, &fieldlen0);
7237  hid_t item_type0=H5Tget_super(fieldtype0);
7238  size_t nullpos1key;
7239  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
7240  unsigned int total_size1key=H5Tget_size(fieldtype1key);
7241  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
7242  std::map<std::string, std::map<std::string, double>> x0;
7243  for(unsigned int k0=0;k0<fieldlen0;++k0){
7244  std::string x1key;
7245  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
7246  nullpos1key=x1key.find('\0');
7247  if(nullpos1key!=std::string::npos){
7248  x1key.resize(nullpos1key);
7249 
7250  }
7251  std::map<std::string, double> x1val;
7252  x1val=VLRead<std::map<std::string, double>,VL_MAP_STRING_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
7253  x0[x1key]=x1val;
7254 
7255  }
7256  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7257  if(is_row_selected){
7258  row[j]=x0;
7259 
7260  }
7261  H5Tclose(fieldtype1key);
7262  H5Tclose(item_type0);
7263  H5Tclose(fieldtype0);
7264  break;
7265 
7266  }
7268  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
7269  unsigned int total_size0=H5Tget_size(fieldtype0);
7270  hsize_t fieldlen0;
7271  H5Tget_array_dims2(fieldtype0, &fieldlen0);
7272  hid_t item_type0=H5Tget_super(fieldtype0);
7273  size_t nullpos1key;
7274  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
7275  unsigned int total_size1key=H5Tget_size(fieldtype1key);
7276  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
7277  std::map<std::string, std::map<std::string, double>> x0;
7278  for(unsigned int k0=0;k0<fieldlen0;++k0){
7279  std::string x1key;
7280  x1key=std::string(buf+offset+(total_size1key+total_size1val)*k0, total_size1key);
7281  nullpos1key=x1key.find('\0');
7282  if(nullpos1key!=std::string::npos){
7283  x1key.resize(nullpos1key);
7284 
7285  }
7286  std::map<std::string, double> x1val;
7287  x1val=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
7288  x0[x1key]=x1val;
7289 
7290  }
7291  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7292  if(is_row_selected){
7293  row[j]=x0;
7294 
7295  }
7296  H5Tclose(fieldtype1key);
7297  H5Tclose(item_type0);
7298  H5Tclose(fieldtype0);
7299  break;
7300 
7301  }
7303  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
7304  unsigned int total_size0=H5Tget_size(fieldtype0);
7305  hsize_t fieldlen0;
7306  H5Tget_array_dims2(fieldtype0, &fieldlen0);
7307  hid_t item_type0=H5Tget_super(fieldtype0);
7308  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
7309  unsigned int total_size1key=H5Tget_size(fieldtype1key);
7310  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
7311  unsigned int total_size1val=H5Tget_size(fieldtype1val);
7312  hsize_t fieldlen1val;
7313  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
7314  hid_t item_type1val=H5Tget_super(fieldtype1val);
7315  size_t nullpos2valkey;
7316  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
7317  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
7318  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
7319  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
7320  std::map<std::string, std::map<std::string, double>> x0;
7321  for(unsigned int k0=0;k0<fieldlen0;++k0){
7322  std::string x1key;
7323  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
7324  std::map<std::string, double> x1val;
7325  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
7326  std::string x2valkey;
7327  x2valkey=std::string(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val, total_size2valkey);
7328  nullpos2valkey=x2valkey.find('\0');
7329  if(nullpos2valkey!=std::string::npos){
7330  x2valkey.resize(nullpos2valkey);
7331 
7332  }
7333  double x2valval;
7334  x2valval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
7335  x1val[x2valkey]=x2valval;
7336 
7337  }
7338  x0[x1key]=x1val;
7339 
7340  }
7341  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7342  if(is_row_selected){
7343  row[j]=x0;
7344 
7345  }
7346  H5Tclose(fieldtype2valval);
7347  H5Tclose(fieldtype2valkey);
7348  H5Tclose(item_type1val);
7349  H5Tclose(fieldtype1val);
7350  H5Tclose(fieldtype1key);
7351  H5Tclose(item_type0);
7352  H5Tclose(fieldtype0);
7353  break;
7354 
7355  }
7357  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
7358  unsigned int total_size0=H5Tget_size(fieldtype0);
7359  hsize_t fieldlen0;
7360  H5Tget_array_dims2(fieldtype0, &fieldlen0);
7361  hid_t item_type0=H5Tget_super(fieldtype0);
7362  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
7363  unsigned int total_size1key=H5Tget_size(fieldtype1key);
7364  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
7365  std::map<std::string, std::map<std::string, double>> x0;
7366  for(unsigned int k0=0;k0<fieldlen0;++k0){
7367  std::string x1key;
7368  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
7369  std::map<std::string, double> x1val;
7370  x1val=VLRead<std::map<std::string, double>,VL_MAP_STRING_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
7371  x0[x1key]=x1val;
7372 
7373  }
7374  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7375  if(is_row_selected){
7376  row[j]=x0;
7377 
7378  }
7379  H5Tclose(fieldtype1key);
7380  H5Tclose(item_type0);
7381  H5Tclose(fieldtype0);
7382  break;
7383 
7384  }
7386  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
7387  unsigned int total_size0=H5Tget_size(fieldtype0);
7388  hsize_t fieldlen0;
7389  H5Tget_array_dims2(fieldtype0, &fieldlen0);
7390  hid_t item_type0=H5Tget_super(fieldtype0);
7391  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
7392  unsigned int total_size1key=H5Tget_size(fieldtype1key);
7393  hid_t fieldtype1val=H5Tget_member_type(item_type0, 1);
7394  unsigned int total_size1val=H5Tget_size(fieldtype1val);
7395  hsize_t fieldlen1val;
7396  H5Tget_array_dims2(fieldtype1val, &fieldlen1val);
7397  hid_t item_type1val=H5Tget_super(fieldtype1val);
7398  hid_t fieldtype2valkey=H5Tget_member_type(item_type1val, 0);
7399  unsigned int total_size2valkey=H5Tget_size(fieldtype2valkey);
7400  hid_t fieldtype2valval=H5Tget_member_type(item_type1val, 1);
7401  unsigned int total_size2valval=H5Tget_size(fieldtype2valval);
7402  std::map<std::string, std::map<std::string, double>> x0;
7403  for(unsigned int k0=0;k0<fieldlen0;++k0){
7404  std::string x1key;
7405  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
7406  std::map<std::string, double> x1val;
7407  for(unsigned int k1val=0;k1val<fieldlen1val;++k1val){
7408  std::string x2valkey;
7409  x2valkey=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val);
7410  double x2valval;
7411  x2valval=*reinterpret_cast<double*>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key+(total_size2valkey+total_size2valval)*k1val+total_size2valkey);
7412  x1val[x2valkey]=x2valval;
7413 
7414  }
7415  x0[x1key]=x1val;
7416 
7417  }
7418  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7419  if(is_row_selected){
7420  row[j]=x0;
7421 
7422  }
7423  H5Tclose(fieldtype2valval);
7424  H5Tclose(fieldtype2valkey);
7425  H5Tclose(item_type1val);
7426  H5Tclose(fieldtype1val);
7427  H5Tclose(fieldtype1key);
7428  H5Tclose(item_type0);
7429  H5Tclose(fieldtype0);
7430  break;
7431 
7432  }
7434  hid_t fieldtype0=H5Tget_member_type(tb_type, j);
7435  unsigned int total_size0=H5Tget_size(fieldtype0);
7436  hsize_t fieldlen0;
7437  H5Tget_array_dims2(fieldtype0, &fieldlen0);
7438  hid_t item_type0=H5Tget_super(fieldtype0);
7439  hid_t fieldtype1key=H5Tget_member_type(item_type0, 0);
7440  unsigned int total_size1key=H5Tget_size(fieldtype1key);
7441  unsigned int total_size1val=CYCLUS_SHA1_SIZE;
7442  std::map<std::string, std::map<std::string, double>> x0;
7443  for(unsigned int k0=0;k0<fieldlen0;++k0){
7444  std::string x1key;
7445  x1key=VLRead<std::string,VL_STRING>(buf+offset+(total_size1key+total_size1val)*k0);
7446  std::map<std::string, double> x1val;
7447  x1val=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(buf+offset+(total_size1key+total_size1val)*k0+total_size1key);
7448  x0[x1key]=x1val;
7449 
7450  }
7451  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7452  if(is_row_selected){
7453  row[j]=x0;
7454 
7455  }
7456  H5Tclose(fieldtype1key);
7457  H5Tclose(item_type0);
7458  H5Tclose(fieldtype0);
7459  break;
7460 
7461  }
7463  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7464  std::map<std::string, std::map<std::string, double>> x0;
7465  x0=VLRead<std::map<std::string, std::map<std::string, double>>,VL_MAP_STRING_MAP_STRING_DOUBLE>(buf+offset);
7466  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7467  if(is_row_selected){
7468  row[j]=x0;
7469 
7470  }
7471  break;
7472 
7473  }
7475  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7476  std::map<std::string, std::map<std::string, double>> x0;
7477  x0=VLRead<std::map<std::string, std::map<std::string, double>>,VL_MAP_VL_STRING_MAP_STRING_DOUBLE>(buf+offset);
7478  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7479  if(is_row_selected){
7480  row[j]=x0;
7481 
7482  }
7483  break;
7484 
7485  }
7487  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7488  std::map<std::string, std::map<std::string, double>> x0;
7489  x0=VLRead<std::map<std::string, std::map<std::string, double>>,VL_MAP_STRING_VL_MAP_STRING_DOUBLE>(buf+offset);
7490  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7491  if(is_row_selected){
7492  row[j]=x0;
7493 
7494  }
7495  break;
7496 
7497  }
7499  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7500  std::map<std::string, std::map<std::string, double>> x0;
7501  x0=VLRead<std::map<std::string, std::map<std::string, double>>,VL_MAP_STRING_MAP_VL_STRING_DOUBLE>(buf+offset);
7502  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7503  if(is_row_selected){
7504  row[j]=x0;
7505 
7506  }
7507  break;
7508 
7509  }
7511  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7512  std::map<std::string, std::map<std::string, double>> x0;
7513  x0=VLRead<std::map<std::string, std::map<std::string, double>>,VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset);
7514  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7515  if(is_row_selected){
7516  row[j]=x0;
7517 
7518  }
7519  break;
7520 
7521  }
7523  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7524  std::map<std::string, std::map<std::string, double>> x0;
7525  x0=VLRead<std::map<std::string, std::map<std::string, double>>,VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE>(buf+offset);
7526  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7527  if(is_row_selected){
7528  row[j]=x0;
7529 
7530  }
7531  break;
7532 
7533  }
7535  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7536  std::map<std::string, std::map<std::string, double>> x0;
7537  x0=VLRead<std::map<std::string, std::map<std::string, double>>,VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE>(buf+offset);
7538  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7539  if(is_row_selected){
7540  row[j]=x0;
7541 
7542  }
7543  break;
7544 
7545  }
7547  unsigned int total_size0=CYCLUS_SHA1_SIZE;
7548  std::map<std::string, std::map<std::string, double>> x0;
7549  x0=VLRead<std::map<std::string, std::map<std::string, double>>,VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset);
7550  is_row_selected=CmpConds<std::map<std::string, std::map<std::string, double>>>(&x0, &(field_conds[qr.fields[j]]));
7551  if(is_row_selected){
7552  row[j]=x0;
7553 
7554  }
7555  break;
7556 
7557  }
7558 
7559 
7560  default: {
7561  throw IOError("querying column '" + qr.fields[j] + "' in table '" + \
7562  table + "' failed due to unsupported data type.");
7563  break;
7564  }
7565  }
7566  if (!is_row_selected)
7567  break;
7568  offset += col_sizes_[table][j];
7569  }
7570  if (is_row_selected) {
7571  qr.rows.push_back(row);
7572  }
7573  }
7574  delete[] buf;
7575  H5Sclose(memspace);
7576  }
7577 
7578  // close and return
7579  H5Tclose(tb_type);
7580  H5Pclose(tb_plist);
7581  H5Sclose(tb_space);
7582  H5Dclose(tb_set);
7583  return qr;
7584 }
7585 
7586 QueryResult Hdf5Back::GetTableInfo(std::string title, hid_t dset, hid_t dt) {
7587  int i;
7588  char * colname;
7589  hsize_t ncols = H5Tget_nmembers(dt);
7590  std::string fieldname;
7591  std::string fieldtype;
7592  LoadTableTypes(title, dset, ncols);
7593  DbTypes* dbtypes = schemas_[title];
7594 
7595  QueryResult qr;
7596  for (i = 0; i < ncols; ++i) {
7597  colname = H5Tget_member_name(dt, i);
7598  fieldname = std::string(colname);
7599  free(colname);
7600  qr.fields.push_back(fieldname);
7601  qr.types.push_back(dbtypes[i]);
7602  }
7603  return qr;
7604 }
7605 
7606 void Hdf5Back::LoadTableTypes(std::string title, hsize_t ncols, Datum *d) {
7607  if (schemas_.count(title) > 0)
7608  return;
7609 
7610  hid_t dset = H5Dopen2(file_, title.c_str(), H5P_DEFAULT);
7611  if(dset < 0) {
7612  CreateTable(d);
7613  return;
7614  }
7615  LoadTableTypes(title, dset, ncols);
7616  H5Dclose(dset);
7617 }
7618 
7619 void Hdf5Back::LoadTableTypes(std::string title, hid_t dset, hsize_t ncols) {
7620  if (schemas_.count(title) > 0)
7621  return;
7622 
7623  int i;
7624  hid_t subt;
7625  hid_t t = H5Dget_type(dset);
7626  schema_sizes_[title] = H5Tget_size(t);
7627  size_t* offsets = new size_t[ncols];
7628  size_t* sizes = new size_t[ncols];
7629  for (i = 0; i < ncols; ++i) {
7630  offsets[i] = H5Tget_member_offset(t, i);
7631  subt = H5Tget_member_type(t, i);
7632  sizes[i] = H5Tget_size(subt);
7633  H5Tclose(subt);
7634  }
7635  H5Tclose(t);
7636  col_offsets_[title] = offsets;
7637  col_sizes_[title] = sizes;
7638 
7639  // get types from db
7640  int dbt[ncols];
7641  hid_t dbtypes_attr = H5Aopen(dset, "cyclus_dbtypes", H5P_DEFAULT);
7642  hid_t dbtypes_type = H5Aget_type(dbtypes_attr);
7643  H5Aread(dbtypes_attr, dbtypes_type, dbt);
7644  H5Tclose(dbtypes_type);
7645  H5Aclose(dbtypes_attr);
7646 
7647  // store types
7648  DbTypes* dbtypes = new DbTypes[ncols];
7649  for (i = 0; i < ncols; ++i)
7650  dbtypes[i] = static_cast<DbTypes>(dbt[i]);
7651  schemas_[title] = dbtypes;
7652 }
7653 
7654 hid_t Hdf5Back::CreateFLStrType(int n) {
7655  hid_t str_type = H5Tcopy(H5T_C_S1);
7656  H5Tset_size(str_type, n);
7657  H5Tset_strpad(str_type, H5T_STR_NULLPAD);
7658  opened_types_.insert(str_type);
7659  return str_type;
7660 }
7661 
7663  return path_;
7664 }
7665 
7666 void Hdf5Back::CreateTable(Datum* d) {
7667  using std::set;
7668  using std::string;
7669  using std::vector;
7670  using std::list;
7671  using std::pair;
7672  using std::list;
7673  using std::map;
7674  Datum::Vals vals = d->vals();
7675  hsize_t nvals = vals.size();
7676  Datum::Shape shape;
7677  Datum::Shapes shapes = d->shapes();
7678 
7679  herr_t status;
7680  size_t dst_size = 0;
7681  size_t* dst_offset = new size_t[nvals];
7682  size_t* dst_sizes = new size_t[nvals];
7683  hid_t field_types[nvals];
7684  DbTypes* dbtypes = new DbTypes[nvals];
7685  const char* field_names[nvals];
7686  for (int i = 0; i < nvals; ++i) {
7687  dst_offset[i] = dst_size;
7688  field_names[i] = vals[i].first;
7689  const std::type_info& valtype = vals[i].second.type();
7690  if(valtype==typeid(std::map<std::string, std::map<std::string, double>>)){
7691  shape=shapes[i];
7692  if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[3]<1){
7694  hid_t item_type0;
7695  hid_t item_type1key;
7696  item_type1key=sha1_type_;
7697  hid_t item_type1val;
7698  hid_t item_type2key;
7699  item_type2key=sha1_type_;
7700  hid_t item_type2val;
7701  item_type2val=H5T_NATIVE_DOUBLE;
7702  hid_t item_type2valcompound;
7703  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7704  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7705  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7706  item_type1val=sha1_type_;
7707  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7708  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7709  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7710 
7711  }
7712  hid_t item_type1compound;
7713  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
7714  H5Tinsert(item_type1compound, "key", 0, item_type1key);
7715  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7716  item_type0=sha1_type_;
7717  if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE)==0){
7718  vldts_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
7719  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE]);
7720 
7721  }
7722  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
7723  field_types[i]=sha1_type_;
7724 
7725  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[3]<1){
7727  hid_t item_type0;
7728  hsize_t shape01=shape[0];
7729  hid_t item_type1key;
7730  item_type1key=CreateFLStrType(shape[1]);
7731  hid_t item_type1val;
7732  hsize_t shape02=shape[2];
7733  hid_t item_type2key;
7734  item_type2key=sha1_type_;
7735  hid_t item_type2val;
7736  item_type2val=H5T_NATIVE_DOUBLE;
7737  hid_t item_type2valcompound;
7738  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7739  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7740  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7741  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
7742  hid_t item_type1compound;
7743  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]));
7744  H5Tinsert(item_type1compound, "key", 0, item_type1key);
7745  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
7746  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7747  dst_sizes[i]=((shape[1]+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
7748  field_types[i]=item_type0;
7749  opened_types_.insert(item_type2valcompound);
7750  opened_types_.insert(item_type1val);
7751  opened_types_.insert(item_type1compound);
7752  opened_types_.insert(field_types[i]);
7753 
7754  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[3]>=1){
7756  hid_t item_type0;
7757  hsize_t shape01=shape[0];
7758  hid_t item_type1key;
7759  item_type1key=CreateFLStrType(shape[1]);
7760  hid_t item_type1val;
7761  hid_t item_type2key;
7762  item_type2key=sha1_type_;
7763  hid_t item_type2val;
7764  item_type2val=H5T_NATIVE_DOUBLE;
7765  hid_t item_type2valcompound;
7766  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7767  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7768  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7769  item_type1val=sha1_type_;
7770  if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
7771  vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7772  opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
7773 
7774  }
7775  hid_t item_type1compound;
7776  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
7777  H5Tinsert(item_type1compound, "key", 0, item_type1key);
7778  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
7779  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7780  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
7781  field_types[i]=item_type0;
7782  opened_types_.insert(item_type2valcompound);
7783  opened_types_.insert(item_type1val);
7784  opened_types_.insert(item_type1compound);
7785  opened_types_.insert(field_types[i]);
7786 
7787  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[3]<1){
7789  hid_t item_type0;
7790  hsize_t shape01=shape[0];
7791  hid_t item_type1key;
7792  item_type1key=CreateFLStrType(shape[1]);
7793  hid_t item_type1val;
7794  hid_t item_type2key;
7795  item_type2key=sha1_type_;
7796  hid_t item_type2val;
7797  item_type2val=H5T_NATIVE_DOUBLE;
7798  hid_t item_type2valcompound;
7799  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7800  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7801  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7802  item_type1val=sha1_type_;
7803  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7804  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7805  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7806 
7807  }
7808  hid_t item_type1compound;
7809  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
7810  H5Tinsert(item_type1compound, "key", 0, item_type1key);
7811  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
7812  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7813  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
7814  field_types[i]=item_type0;
7815  opened_types_.insert(item_type2valcompound);
7816  opened_types_.insert(item_type1val);
7817  opened_types_.insert(item_type1compound);
7818  opened_types_.insert(field_types[i]);
7819 
7820  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[3]>=1){
7822  hid_t item_type0;
7823  hsize_t shape01=shape[0];
7824  hid_t item_type1key;
7825  item_type1key=sha1_type_;
7826  hid_t item_type1val;
7827  hsize_t shape02=shape[2];
7828  hid_t item_type2key;
7829  item_type2key=CreateFLStrType(shape[3]);
7830  hid_t item_type2val;
7831  item_type2val=H5T_NATIVE_DOUBLE;
7832  hid_t item_type2valcompound;
7833  item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(double));
7834  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7835  H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
7836  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
7837  hid_t item_type1compound;
7838  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((shape[3]+sizeof(double))*shape[2]));
7839  H5Tinsert(item_type1compound, "key", 0, item_type1key);
7840  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7841  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7842  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
7843  field_types[i]=item_type0;
7844  opened_types_.insert(item_type2valcompound);
7845  opened_types_.insert(item_type1val);
7846  opened_types_.insert(item_type1compound);
7847  opened_types_.insert(field_types[i]);
7848 
7849  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[3]>=1){
7851  hid_t item_type0;
7852  hsize_t shape01=shape[0];
7853  hid_t item_type1key;
7854  item_type1key=sha1_type_;
7855  hid_t item_type1val;
7856  hid_t item_type2key;
7857  item_type2key=sha1_type_;
7858  hid_t item_type2val;
7859  item_type2val=H5T_NATIVE_DOUBLE;
7860  hid_t item_type2valcompound;
7861  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7862  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7863  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7864  item_type1val=sha1_type_;
7865  if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
7866  vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7867  opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
7868 
7869  }
7870  hid_t item_type1compound;
7871  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
7872  H5Tinsert(item_type1compound, "key", 0, item_type1key);
7873  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7874  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7875  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
7876  field_types[i]=item_type0;
7877  opened_types_.insert(item_type2valcompound);
7878  opened_types_.insert(item_type1val);
7879  opened_types_.insert(item_type1compound);
7880  opened_types_.insert(field_types[i]);
7881 
7882  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[3]<1){
7884  hid_t item_type0;
7885  hsize_t shape01=shape[0];
7886  hid_t item_type1key;
7887  item_type1key=sha1_type_;
7888  hid_t item_type1val;
7889  hsize_t shape02=shape[2];
7890  hid_t item_type2key;
7891  item_type2key=sha1_type_;
7892  hid_t item_type2val;
7893  item_type2val=H5T_NATIVE_DOUBLE;
7894  hid_t item_type2valcompound;
7895  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7896  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7897  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7898  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
7899  hid_t item_type1compound;
7900  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]));
7901  H5Tinsert(item_type1compound, "key", 0, item_type1key);
7902  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7903  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7904  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
7905  field_types[i]=item_type0;
7906  opened_types_.insert(item_type2valcompound);
7907  opened_types_.insert(item_type1val);
7908  opened_types_.insert(item_type1compound);
7909  opened_types_.insert(field_types[i]);
7910 
7911  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[3]<1){
7913  hid_t item_type0;
7914  hsize_t shape01=shape[0];
7915  hid_t item_type1key;
7916  item_type1key=sha1_type_;
7917  hid_t item_type1val;
7918  hid_t item_type2key;
7919  item_type2key=sha1_type_;
7920  hid_t item_type2val;
7921  item_type2val=H5T_NATIVE_DOUBLE;
7922  hid_t item_type2valcompound;
7923  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7924  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7925  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7926  item_type1val=sha1_type_;
7927  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7928  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7929  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7930 
7931  }
7932  hid_t item_type1compound;
7933  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
7934  H5Tinsert(item_type1compound, "key", 0, item_type1key);
7935  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7936  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
7937  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
7938  field_types[i]=item_type0;
7939  opened_types_.insert(item_type2valcompound);
7940  opened_types_.insert(item_type1val);
7941  opened_types_.insert(item_type1compound);
7942  opened_types_.insert(field_types[i]);
7943 
7944  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[3]>=1){
7946  hid_t item_type0;
7947  hid_t item_type1key;
7948  item_type1key=sha1_type_;
7949  hid_t item_type1val;
7950  hsize_t shape02=shape[2];
7951  hid_t item_type2key;
7952  item_type2key=sha1_type_;
7953  hid_t item_type2val;
7954  item_type2val=H5T_NATIVE_DOUBLE;
7955  hid_t item_type2valcompound;
7956  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7957  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7958  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7959  item_type1val=sha1_type_;
7960  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7961  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7962  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7963 
7964  }
7965  hid_t item_type1compound;
7966  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
7967  H5Tinsert(item_type1compound, "key", 0, item_type1key);
7968  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
7969  item_type0=sha1_type_;
7970  if(vldts_.count(VL_MAP_STRING_MAP_STRING_DOUBLE)==0){
7971  vldts_[VL_MAP_STRING_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
7972  opened_types_.insert(vldts_[VL_MAP_STRING_MAP_STRING_DOUBLE]);
7973 
7974  }
7975  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
7976  field_types[i]=sha1_type_;
7977 
7978  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[3]>=1){
7980  hid_t item_type0;
7981  hid_t item_type1key;
7982  item_type1key=sha1_type_;
7983  hid_t item_type1val;
7984  hsize_t shape02=shape[2];
7985  hid_t item_type2key;
7986  item_type2key=sha1_type_;
7987  hid_t item_type2val;
7988  item_type2val=H5T_NATIVE_DOUBLE;
7989  hid_t item_type2valcompound;
7990  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
7991  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
7992  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
7993  item_type1val=sha1_type_;
7994  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
7995  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
7996  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
7997 
7998  }
7999  hid_t item_type1compound;
8000  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8001  H5Tinsert(item_type1compound, "key", 0, item_type1key);
8002  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8003  item_type0=sha1_type_;
8004  if(vldts_.count(VL_MAP_VL_STRING_MAP_STRING_DOUBLE)==0){
8005  vldts_[VL_MAP_VL_STRING_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8006  opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_STRING_DOUBLE]);
8007 
8008  }
8009  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8010  field_types[i]=sha1_type_;
8011 
8012  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[3]>=1){
8014  hid_t item_type0;
8015  hid_t item_type1key;
8016  item_type1key=sha1_type_;
8017  hid_t item_type1val;
8018  hid_t item_type2key;
8019  item_type2key=sha1_type_;
8020  hid_t item_type2val;
8021  item_type2val=H5T_NATIVE_DOUBLE;
8022  hid_t item_type2valcompound;
8023  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8024  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8025  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8026  item_type1val=sha1_type_;
8027  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8028  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8029  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8030 
8031  }
8032  hid_t item_type1compound;
8033  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8034  H5Tinsert(item_type1compound, "key", 0, item_type1key);
8035  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8036  item_type0=sha1_type_;
8037  if(vldts_.count(VL_MAP_STRING_VL_MAP_STRING_DOUBLE)==0){
8038  vldts_[VL_MAP_STRING_VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8039  opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_STRING_DOUBLE]);
8040 
8041  }
8042  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8043  field_types[i]=sha1_type_;
8044 
8045  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[3]<1){
8047  hid_t item_type0;
8048  hid_t item_type1key;
8049  item_type1key=sha1_type_;
8050  hid_t item_type1val;
8051  hsize_t shape02=shape[2];
8052  hid_t item_type2key;
8053  item_type2key=sha1_type_;
8054  hid_t item_type2val;
8055  item_type2val=H5T_NATIVE_DOUBLE;
8056  hid_t item_type2valcompound;
8057  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8058  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8059  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8060  item_type1val=sha1_type_;
8061  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8062  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8063  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8064 
8065  }
8066  hid_t item_type1compound;
8067  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8068  H5Tinsert(item_type1compound, "key", 0, item_type1key);
8069  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8070  item_type0=sha1_type_;
8071  if(vldts_.count(VL_MAP_STRING_MAP_VL_STRING_DOUBLE)==0){
8072  vldts_[VL_MAP_STRING_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8073  opened_types_.insert(vldts_[VL_MAP_STRING_MAP_VL_STRING_DOUBLE]);
8074 
8075  }
8076  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8077  field_types[i]=sha1_type_;
8078 
8079  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[3]<1){
8081  hid_t item_type0;
8082  hid_t item_type1key;
8083  item_type1key=sha1_type_;
8084  hid_t item_type1val;
8085  hid_t item_type2key;
8086  item_type2key=sha1_type_;
8087  hid_t item_type2val;
8088  item_type2val=H5T_NATIVE_DOUBLE;
8089  hid_t item_type2valcompound;
8090  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8091  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8092  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8093  item_type1val=sha1_type_;
8094  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8095  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8096  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8097 
8098  }
8099  hid_t item_type1compound;
8100  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8101  H5Tinsert(item_type1compound, "key", 0, item_type1key);
8102  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8103  item_type0=sha1_type_;
8104  if(vldts_.count(VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE)==0){
8105  vldts_[VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8106  opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE]);
8107 
8108  }
8109  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8110  field_types[i]=sha1_type_;
8111 
8112  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[3]<1){
8114  hid_t item_type0;
8115  hid_t item_type1key;
8116  item_type1key=sha1_type_;
8117  hid_t item_type1val;
8118  hsize_t shape02=shape[2];
8119  hid_t item_type2key;
8120  item_type2key=sha1_type_;
8121  hid_t item_type2val;
8122  item_type2val=H5T_NATIVE_DOUBLE;
8123  hid_t item_type2valcompound;
8124  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8125  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8126  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8127  item_type1val=sha1_type_;
8128  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8129  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8130  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8131 
8132  }
8133  hid_t item_type1compound;
8134  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8135  H5Tinsert(item_type1compound, "key", 0, item_type1key);
8136  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8137  item_type0=sha1_type_;
8138  if(vldts_.count(VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE)==0){
8139  vldts_[VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8140  opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE]);
8141 
8142  }
8143  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8144  field_types[i]=sha1_type_;
8145 
8146  }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[3]>=1){
8148  hid_t item_type0;
8149  hid_t item_type1key;
8150  item_type1key=sha1_type_;
8151  hid_t item_type1val;
8152  hid_t item_type2key;
8153  item_type2key=sha1_type_;
8154  hid_t item_type2val;
8155  item_type2val=H5T_NATIVE_DOUBLE;
8156  hid_t item_type2valcompound;
8157  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
8158  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8159  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
8160  item_type1val=sha1_type_;
8161  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
8162  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
8163  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
8164 
8165  }
8166  hid_t item_type1compound;
8167  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
8168  H5Tinsert(item_type1compound, "key", 0, item_type1key);
8169  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
8170  item_type0=sha1_type_;
8171  if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE)==0){
8172  vldts_[VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
8173  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE]);
8174 
8175  }
8176  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8177  field_types[i]=sha1_type_;
8178 
8179  }else{
8180  dbtypes[i]=MAP_STRING_MAP_STRING_DOUBLE;
8181  hid_t item_type0;
8182  hsize_t shape01=shape[0];
8183  hid_t item_type1key;
8184  item_type1key=CreateFLStrType(shape[1]);
8185  hid_t item_type1val;
8186  hsize_t shape02=shape[2];
8187  hid_t item_type2key;
8188  item_type2key=CreateFLStrType(shape[3]);
8189  hid_t item_type2val;
8190  item_type2val=H5T_NATIVE_DOUBLE;
8191  hid_t item_type2valcompound;
8192  item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(double));
8193  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
8194  H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
8195  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
8196  hid_t item_type1compound;
8197  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((shape[3]+sizeof(double))*shape[2]));
8198  H5Tinsert(item_type1compound, "key", 0, item_type1key);
8199  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
8200  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
8201  dst_sizes[i]=((shape[1]+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
8202  field_types[i]=item_type0;
8203  opened_types_.insert(item_type2valcompound);
8204  opened_types_.insert(item_type1val);
8205  opened_types_.insert(item_type1compound);
8206  opened_types_.insert(field_types[i]);
8207 
8208  }
8209 
8210  }else if(valtype==typeid(bool)){
8211  shape=shapes[i];
8212  dbtypes[i]=BOOL;
8213  hid_t item_type0;
8214  item_type0=H5T_NATIVE_CHAR;
8215  dst_sizes[i]=sizeof(char);
8216  field_types[i]=item_type0;
8217 
8218  }else if(valtype==typeid(int)){
8219  shape=shapes[i];
8220  dbtypes[i]=INT;
8221  hid_t item_type0;
8222  item_type0=H5T_NATIVE_INT;
8223  dst_sizes[i]=sizeof(int);
8224  field_types[i]=item_type0;
8225 
8226  }else if(valtype==typeid(float)){
8227  shape=shapes[i];
8228  dbtypes[i]=FLOAT;
8229  hid_t item_type0;
8230  item_type0=H5T_NATIVE_FLOAT;
8231  dst_sizes[i]=sizeof(float);
8232  field_types[i]=item_type0;
8233 
8234  }else if(valtype==typeid(double)){
8235  shape=shapes[i];
8236  dbtypes[i]=DOUBLE;
8237  hid_t item_type0;
8238  item_type0=H5T_NATIVE_DOUBLE;
8239  dst_sizes[i]=sizeof(double);
8240  field_types[i]=item_type0;
8241 
8242  }else if(valtype==typeid(std::string)){
8243  shape=shapes[i];
8244  if(shape.empty()||shape[0]<1){
8245  dbtypes[i]=VL_STRING;
8246  hid_t item_type0;
8247  item_type0=sha1_type_;
8248  dst_sizes[i]=CYCLUS_SHA1_SIZE;
8249  field_types[i]=sha1_type_;
8250 
8251  }else{
8252  dbtypes[i]=STRING;
8253  field_types[i]=H5Tcopy(H5T_C_S1);
8254  H5Tset_size(field_types[i], shape[0]);
8255  H5Tset_strpad(field_types[i], H5T_STR_NULLPAD);
8256  opened_types_.insert(field_types[i]);
8257  dst_sizes[i]=sizeof(char)*shape[0];
8258 
8259  }
8260 
8261  }else if(valtype==typeid(cyclus::Blob)){
8262  shape=shapes[i];
8263  dbtypes[i]=BLOB;
8264  field_types[i]=sha1_type_;
8265  dst_sizes[i]=CYCLUS_SHA1_SIZE;
8266 
8267  }else if(valtype==typeid(boost::uuids::uuid)){
8268  shape=shapes[i];
8269  dbtypes[i]=UUID;
8270  hid_t item_type0;
8271  item_type0=uuid_type_;
8272  dst_sizes[i]=CYCLUS_UUID_SIZE;
8273  field_types[i]=item_type0;
8274 
8275  }else if(valtype==typeid(std::vector<int>)){
8276  shape=shapes[i];
8277  if(shape.empty()||shape[0]<1){
8278  dbtypes[i]=VL_VECTOR_INT;
8279  hid_t item_type0;
8280  hid_t item_type1elem;
8281  item_type1elem=H5T_NATIVE_INT;
8282  item_type0=sha1_type_;
8283  if(vldts_.count(VL_VECTOR_INT)==0){
8284  vldts_[VL_VECTOR_INT]=H5Tvlen_create(item_type1elem);
8285  opened_types_.insert(vldts_[VL_VECTOR_INT]);
8286 
8287  }
8288  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8289  field_types[i]=sha1_type_;
8290 
8291  }else{
8292  dbtypes[i]=VECTOR_INT;
8293  hid_t item_type0;
8294  hsize_t shape01=shape[0];
8295  hid_t item_type1elem;
8296  item_type1elem=H5T_NATIVE_INT;
8297  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8298  dst_sizes[i]=((sizeof(int))*shape[0]);
8299  field_types[i]=item_type0;
8300  opened_types_.insert(field_types[i]);
8301 
8302  }
8303 
8304  }else if(valtype==typeid(std::vector<float>)){
8305  shape=shapes[i];
8306  if(shape.empty()||shape[0]<1){
8307  dbtypes[i]=VL_VECTOR_FLOAT;
8308  hid_t item_type0;
8309  hid_t item_type1elem;
8310  item_type1elem=H5T_NATIVE_FLOAT;
8311  item_type0=sha1_type_;
8312  if(vldts_.count(VL_VECTOR_FLOAT)==0){
8313  vldts_[VL_VECTOR_FLOAT]=H5Tvlen_create(item_type1elem);
8314  opened_types_.insert(vldts_[VL_VECTOR_FLOAT]);
8315 
8316  }
8317  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8318  field_types[i]=sha1_type_;
8319 
8320  }else{
8321  dbtypes[i]=VECTOR_FLOAT;
8322  hid_t item_type0;
8323  hsize_t shape01=shape[0];
8324  hid_t item_type1elem;
8325  item_type1elem=H5T_NATIVE_FLOAT;
8326  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8327  dst_sizes[i]=((sizeof(float))*shape[0]);
8328  field_types[i]=item_type0;
8329  opened_types_.insert(field_types[i]);
8330 
8331  }
8332 
8333  }else if(valtype==typeid(std::vector<double>)){
8334  shape=shapes[i];
8335  if(shape.empty()||shape[0]<1){
8336  dbtypes[i]=VL_VECTOR_DOUBLE;
8337  hid_t item_type0;
8338  hid_t item_type1elem;
8339  item_type1elem=H5T_NATIVE_DOUBLE;
8340  item_type0=sha1_type_;
8341  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
8342  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1elem);
8343  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
8344 
8345  }
8346  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8347  field_types[i]=sha1_type_;
8348 
8349  }else{
8350  dbtypes[i]=VECTOR_DOUBLE;
8351  hid_t item_type0;
8352  hsize_t shape01=shape[0];
8353  hid_t item_type1elem;
8354  item_type1elem=H5T_NATIVE_DOUBLE;
8355  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8356  dst_sizes[i]=((sizeof(double))*shape[0]);
8357  field_types[i]=item_type0;
8358  opened_types_.insert(field_types[i]);
8359 
8360  }
8361 
8362  }else if(valtype==typeid(std::vector<std::string>)){
8363  shape=shapes[i];
8364  if(shape.empty()||shape[0]<1&&shape[1]<1){
8365  dbtypes[i]=VL_VECTOR_VL_STRING;
8366  hid_t item_type0;
8367  hid_t item_type1elem;
8368  item_type1elem=sha1_type_;
8369  item_type0=sha1_type_;
8370  if(vldts_.count(VL_VECTOR_VL_STRING)==0){
8371  vldts_[VL_VECTOR_VL_STRING]=H5Tvlen_create(item_type1elem);
8372  opened_types_.insert(vldts_[VL_VECTOR_VL_STRING]);
8373 
8374  }
8375  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8376  field_types[i]=sha1_type_;
8377 
8378  }else if(shape[0]<1&&shape[1]>=1){
8379  dbtypes[i]=VL_VECTOR_STRING;
8380  hid_t item_type0;
8381  hid_t item_type1elem;
8382  item_type1elem=sha1_type_;
8383  item_type0=sha1_type_;
8384  if(vldts_.count(VL_VECTOR_STRING)==0){
8385  vldts_[VL_VECTOR_STRING]=H5Tvlen_create(item_type1elem);
8386  opened_types_.insert(vldts_[VL_VECTOR_STRING]);
8387 
8388  }
8389  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8390  field_types[i]=sha1_type_;
8391 
8392  }else if(shape[0]>=1&&shape[1]<1){
8393  dbtypes[i]=VECTOR_VL_STRING;
8394  hid_t item_type0;
8395  hsize_t shape01=shape[0];
8396  hid_t item_type1elem;
8397  item_type1elem=sha1_type_;
8398  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8399  dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8400  field_types[i]=item_type0;
8401  opened_types_.insert(field_types[i]);
8402 
8403  }else{
8404  dbtypes[i]=VECTOR_STRING;
8405  hid_t item_type0;
8406  hsize_t shape01=shape[0];
8407  hid_t item_type1elem;
8408  item_type1elem=CreateFLStrType(shape[1]);
8409  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8410  dst_sizes[i]=((shape[1])*shape[0]);
8411  field_types[i]=item_type0;
8412  opened_types_.insert(field_types[i]);
8413 
8414  }
8415 
8416  }else if(valtype==typeid(std::vector<cyclus::Blob>)){
8417  shape=shapes[i];
8418  if(shape.empty()||shape[0]<1&&shape[1]<1){
8419  dbtypes[i]=VL_VECTOR_BLOB;
8420  hid_t item_type0;
8421  hid_t item_type1elem;
8422  item_type1elem=sha1_type_;
8423  item_type0=sha1_type_;
8424  if(vldts_.count(VL_VECTOR_BLOB)==0){
8425  vldts_[VL_VECTOR_BLOB]=H5Tvlen_create(item_type1elem);
8426  opened_types_.insert(vldts_[VL_VECTOR_BLOB]);
8427 
8428  }
8429  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8430  field_types[i]=sha1_type_;
8431 
8432  }else{
8433  dbtypes[i]=VECTOR_BLOB;
8434  hid_t item_type0;
8435  hsize_t shape01=shape[0];
8436  hid_t item_type1elem;
8437  item_type1elem=sha1_type_;
8438  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8439  dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8440  field_types[i]=item_type0;
8441  opened_types_.insert(field_types[i]);
8442 
8443  }
8444 
8445  }else if(valtype==typeid(std::vector<boost::uuids::uuid>)){
8446  shape=shapes[i];
8447  if(shape.empty()||shape[0]<1){
8448  dbtypes[i]=VL_VECTOR_UUID;
8449  hid_t item_type0;
8450  hid_t item_type1elem;
8451  item_type1elem=uuid_type_;
8452  item_type0=sha1_type_;
8453  if(vldts_.count(VL_VECTOR_UUID)==0){
8454  vldts_[VL_VECTOR_UUID]=H5Tvlen_create(item_type1elem);
8455  opened_types_.insert(vldts_[VL_VECTOR_UUID]);
8456 
8457  }
8458  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8459  field_types[i]=sha1_type_;
8460 
8461  }else{
8462  dbtypes[i]=VECTOR_UUID;
8463  hid_t item_type0;
8464  hsize_t shape01=shape[0];
8465  hid_t item_type1elem;
8466  item_type1elem=uuid_type_;
8467  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8468  dst_sizes[i]=((CYCLUS_UUID_SIZE)*shape[0]);
8469  field_types[i]=item_type0;
8470  opened_types_.insert(field_types[i]);
8471 
8472  }
8473 
8474  }else if(valtype==typeid(std::set<int>)){
8475  shape=shapes[i];
8476  if(shape.empty()||shape[0]<1){
8477  dbtypes[i]=VL_SET_INT;
8478  hid_t item_type0;
8479  hid_t item_type1elem;
8480  item_type1elem=H5T_NATIVE_INT;
8481  item_type0=sha1_type_;
8482  if(vldts_.count(VL_SET_INT)==0){
8483  vldts_[VL_SET_INT]=H5Tvlen_create(item_type1elem);
8484  opened_types_.insert(vldts_[VL_SET_INT]);
8485 
8486  }
8487  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8488  field_types[i]=sha1_type_;
8489 
8490  }else{
8491  dbtypes[i]=SET_INT;
8492  hid_t item_type0;
8493  hsize_t shape01=shape[0];
8494  hid_t item_type1elem;
8495  item_type1elem=H5T_NATIVE_INT;
8496  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8497  dst_sizes[i]=((sizeof(int))*shape[0]);
8498  field_types[i]=item_type0;
8499  opened_types_.insert(field_types[i]);
8500 
8501  }
8502 
8503  }else if(valtype==typeid(std::set<float>)){
8504  shape=shapes[i];
8505  if(shape.empty()||shape[0]<1){
8506  dbtypes[i]=VL_SET_FLOAT;
8507  hid_t item_type0;
8508  hid_t item_type1elem;
8509  item_type1elem=H5T_NATIVE_FLOAT;
8510  item_type0=sha1_type_;
8511  if(vldts_.count(VL_SET_FLOAT)==0){
8512  vldts_[VL_SET_FLOAT]=H5Tvlen_create(item_type1elem);
8513  opened_types_.insert(vldts_[VL_SET_FLOAT]);
8514 
8515  }
8516  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8517  field_types[i]=sha1_type_;
8518 
8519  }else{
8520  dbtypes[i]=SET_FLOAT;
8521  hid_t item_type0;
8522  hsize_t shape01=shape[0];
8523  hid_t item_type1elem;
8524  item_type1elem=H5T_NATIVE_FLOAT;
8525  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8526  dst_sizes[i]=((sizeof(float))*shape[0]);
8527  field_types[i]=item_type0;
8528  opened_types_.insert(field_types[i]);
8529 
8530  }
8531 
8532  }else if(valtype==typeid(std::set<double>)){
8533  shape=shapes[i];
8534  if(shape.empty()||shape[0]<1){
8535  dbtypes[i]=VL_SET_DOUBLE;
8536  hid_t item_type0;
8537  hid_t item_type1elem;
8538  item_type1elem=H5T_NATIVE_DOUBLE;
8539  item_type0=sha1_type_;
8540  if(vldts_.count(VL_SET_DOUBLE)==0){
8541  vldts_[VL_SET_DOUBLE]=H5Tvlen_create(item_type1elem);
8542  opened_types_.insert(vldts_[VL_SET_DOUBLE]);
8543 
8544  }
8545  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8546  field_types[i]=sha1_type_;
8547 
8548  }else{
8549  dbtypes[i]=SET_DOUBLE;
8550  hid_t item_type0;
8551  hsize_t shape01=shape[0];
8552  hid_t item_type1elem;
8553  item_type1elem=H5T_NATIVE_DOUBLE;
8554  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8555  dst_sizes[i]=((sizeof(double))*shape[0]);
8556  field_types[i]=item_type0;
8557  opened_types_.insert(field_types[i]);
8558 
8559  }
8560 
8561  }else if(valtype==typeid(std::set<std::string>)){
8562  shape=shapes[i];
8563  if(shape.empty()||shape[0]<1&&shape[1]<1){
8564  dbtypes[i]=VL_SET_VL_STRING;
8565  hid_t item_type0;
8566  hid_t item_type1elem;
8567  item_type1elem=sha1_type_;
8568  item_type0=sha1_type_;
8569  if(vldts_.count(VL_SET_VL_STRING)==0){
8570  vldts_[VL_SET_VL_STRING]=H5Tvlen_create(item_type1elem);
8571  opened_types_.insert(vldts_[VL_SET_VL_STRING]);
8572 
8573  }
8574  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8575  field_types[i]=sha1_type_;
8576 
8577  }else if(shape[0]<1&&shape[1]>=1){
8578  dbtypes[i]=VL_SET_STRING;
8579  hid_t item_type0;
8580  hid_t item_type1elem;
8581  item_type1elem=sha1_type_;
8582  item_type0=sha1_type_;
8583  if(vldts_.count(VL_SET_STRING)==0){
8584  vldts_[VL_SET_STRING]=H5Tvlen_create(item_type1elem);
8585  opened_types_.insert(vldts_[VL_SET_STRING]);
8586 
8587  }
8588  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8589  field_types[i]=sha1_type_;
8590 
8591  }else if(shape[0]>=1&&shape[1]<1){
8592  dbtypes[i]=SET_VL_STRING;
8593  hid_t item_type0;
8594  hsize_t shape01=shape[0];
8595  hid_t item_type1elem;
8596  item_type1elem=sha1_type_;
8597  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8598  dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8599  field_types[i]=item_type0;
8600  opened_types_.insert(field_types[i]);
8601 
8602  }else{
8603  dbtypes[i]=SET_STRING;
8604  hid_t item_type0;
8605  hsize_t shape01=shape[0];
8606  hid_t item_type1elem;
8607  item_type1elem=CreateFLStrType(shape[1]);
8608  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8609  dst_sizes[i]=((shape[1])*shape[0]);
8610  field_types[i]=item_type0;
8611  opened_types_.insert(field_types[i]);
8612 
8613  }
8614 
8615  }else if(valtype==typeid(std::set<cyclus::Blob>)){
8616  shape=shapes[i];
8617  if(shape.empty()||shape[0]<1&&shape[1]<1){
8618  dbtypes[i]=VL_SET_BLOB;
8619  hid_t item_type0;
8620  hid_t item_type1elem;
8621  item_type1elem=sha1_type_;
8622  item_type0=sha1_type_;
8623  if(vldts_.count(VL_SET_BLOB)==0){
8624  vldts_[VL_SET_BLOB]=H5Tvlen_create(item_type1elem);
8625  opened_types_.insert(vldts_[VL_SET_BLOB]);
8626 
8627  }
8628  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8629  field_types[i]=sha1_type_;
8630 
8631  }else{
8632  dbtypes[i]=SET_BLOB;
8633  hid_t item_type0;
8634  hsize_t shape01=shape[0];
8635  hid_t item_type1elem;
8636  item_type1elem=sha1_type_;
8637  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8638  dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8639  field_types[i]=item_type0;
8640  opened_types_.insert(field_types[i]);
8641 
8642  }
8643 
8644  }else if(valtype==typeid(std::set<boost::uuids::uuid>)){
8645  shape=shapes[i];
8646  if(shape.empty()||shape[0]<1){
8647  dbtypes[i]=VL_SET_UUID;
8648  hid_t item_type0;
8649  hid_t item_type1elem;
8650  item_type1elem=uuid_type_;
8651  item_type0=sha1_type_;
8652  if(vldts_.count(VL_SET_UUID)==0){
8653  vldts_[VL_SET_UUID]=H5Tvlen_create(item_type1elem);
8654  opened_types_.insert(vldts_[VL_SET_UUID]);
8655 
8656  }
8657  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8658  field_types[i]=sha1_type_;
8659 
8660  }else{
8661  dbtypes[i]=SET_UUID;
8662  hid_t item_type0;
8663  hsize_t shape01=shape[0];
8664  hid_t item_type1elem;
8665  item_type1elem=uuid_type_;
8666  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8667  dst_sizes[i]=((CYCLUS_UUID_SIZE)*shape[0]);
8668  field_types[i]=item_type0;
8669  opened_types_.insert(field_types[i]);
8670 
8671  }
8672 
8673  }else if(valtype==typeid(std::list<bool>)){
8674  shape=shapes[i];
8675  if(shape.empty()||shape[0]<1){
8676  dbtypes[i]=VL_LIST_BOOL;
8677  hid_t item_type0;
8678  hid_t item_type1elem;
8679  item_type1elem=H5T_NATIVE_CHAR;
8680  item_type0=sha1_type_;
8681  if(vldts_.count(VL_LIST_BOOL)==0){
8682  vldts_[VL_LIST_BOOL]=H5Tvlen_create(item_type1elem);
8683  opened_types_.insert(vldts_[VL_LIST_BOOL]);
8684 
8685  }
8686  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8687  field_types[i]=sha1_type_;
8688 
8689  }else{
8690  dbtypes[i]=LIST_BOOL;
8691  hid_t item_type0;
8692  hsize_t shape01=shape[0];
8693  hid_t item_type1elem;
8694  item_type1elem=H5T_NATIVE_CHAR;
8695  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8696  dst_sizes[i]=((sizeof(char))*shape[0]);
8697  field_types[i]=item_type0;
8698  opened_types_.insert(field_types[i]);
8699 
8700  }
8701 
8702  }else if(valtype==typeid(std::list<int>)){
8703  shape=shapes[i];
8704  if(shape.empty()||shape[0]<1){
8705  dbtypes[i]=VL_LIST_INT;
8706  hid_t item_type0;
8707  hid_t item_type1elem;
8708  item_type1elem=H5T_NATIVE_INT;
8709  item_type0=sha1_type_;
8710  if(vldts_.count(VL_LIST_INT)==0){
8711  vldts_[VL_LIST_INT]=H5Tvlen_create(item_type1elem);
8712  opened_types_.insert(vldts_[VL_LIST_INT]);
8713 
8714  }
8715  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8716  field_types[i]=sha1_type_;
8717 
8718  }else{
8719  dbtypes[i]=LIST_INT;
8720  hid_t item_type0;
8721  hsize_t shape01=shape[0];
8722  hid_t item_type1elem;
8723  item_type1elem=H5T_NATIVE_INT;
8724  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8725  dst_sizes[i]=((sizeof(int))*shape[0]);
8726  field_types[i]=item_type0;
8727  opened_types_.insert(field_types[i]);
8728 
8729  }
8730 
8731  }else if(valtype==typeid(std::list<float>)){
8732  shape=shapes[i];
8733  if(shape.empty()||shape[0]<1){
8734  dbtypes[i]=VL_LIST_FLOAT;
8735  hid_t item_type0;
8736  hid_t item_type1elem;
8737  item_type1elem=H5T_NATIVE_FLOAT;
8738  item_type0=sha1_type_;
8739  if(vldts_.count(VL_LIST_FLOAT)==0){
8740  vldts_[VL_LIST_FLOAT]=H5Tvlen_create(item_type1elem);
8741  opened_types_.insert(vldts_[VL_LIST_FLOAT]);
8742 
8743  }
8744  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8745  field_types[i]=sha1_type_;
8746 
8747  }else{
8748  dbtypes[i]=LIST_FLOAT;
8749  hid_t item_type0;
8750  hsize_t shape01=shape[0];
8751  hid_t item_type1elem;
8752  item_type1elem=H5T_NATIVE_FLOAT;
8753  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8754  dst_sizes[i]=((sizeof(float))*shape[0]);
8755  field_types[i]=item_type0;
8756  opened_types_.insert(field_types[i]);
8757 
8758  }
8759 
8760  }else if(valtype==typeid(std::list<double>)){
8761  shape=shapes[i];
8762  if(shape.empty()||shape[0]<1){
8763  dbtypes[i]=VL_LIST_DOUBLE;
8764  hid_t item_type0;
8765  hid_t item_type1elem;
8766  item_type1elem=H5T_NATIVE_DOUBLE;
8767  item_type0=sha1_type_;
8768  if(vldts_.count(VL_LIST_DOUBLE)==0){
8769  vldts_[VL_LIST_DOUBLE]=H5Tvlen_create(item_type1elem);
8770  opened_types_.insert(vldts_[VL_LIST_DOUBLE]);
8771 
8772  }
8773  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8774  field_types[i]=sha1_type_;
8775 
8776  }else{
8777  dbtypes[i]=LIST_DOUBLE;
8778  hid_t item_type0;
8779  hsize_t shape01=shape[0];
8780  hid_t item_type1elem;
8781  item_type1elem=H5T_NATIVE_DOUBLE;
8782  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8783  dst_sizes[i]=((sizeof(double))*shape[0]);
8784  field_types[i]=item_type0;
8785  opened_types_.insert(field_types[i]);
8786 
8787  }
8788 
8789  }else if(valtype==typeid(std::list<std::string>)){
8790  shape=shapes[i];
8791  if(shape.empty()||shape[0]<1&&shape[1]<1){
8792  dbtypes[i]=VL_LIST_VL_STRING;
8793  hid_t item_type0;
8794  hid_t item_type1elem;
8795  item_type1elem=sha1_type_;
8796  item_type0=sha1_type_;
8797  if(vldts_.count(VL_LIST_VL_STRING)==0){
8798  vldts_[VL_LIST_VL_STRING]=H5Tvlen_create(item_type1elem);
8799  opened_types_.insert(vldts_[VL_LIST_VL_STRING]);
8800 
8801  }
8802  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8803  field_types[i]=sha1_type_;
8804 
8805  }else if(shape[0]<1&&shape[1]>=1){
8806  dbtypes[i]=VL_LIST_STRING;
8807  hid_t item_type0;
8808  hid_t item_type1elem;
8809  item_type1elem=sha1_type_;
8810  item_type0=sha1_type_;
8811  if(vldts_.count(VL_LIST_STRING)==0){
8812  vldts_[VL_LIST_STRING]=H5Tvlen_create(item_type1elem);
8813  opened_types_.insert(vldts_[VL_LIST_STRING]);
8814 
8815  }
8816  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8817  field_types[i]=sha1_type_;
8818 
8819  }else if(shape[0]>=1&&shape[1]<1){
8820  dbtypes[i]=LIST_VL_STRING;
8821  hid_t item_type0;
8822  hsize_t shape01=shape[0];
8823  hid_t item_type1elem;
8824  item_type1elem=sha1_type_;
8825  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8826  dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8827  field_types[i]=item_type0;
8828  opened_types_.insert(field_types[i]);
8829 
8830  }else{
8831  dbtypes[i]=LIST_STRING;
8832  hid_t item_type0;
8833  hsize_t shape01=shape[0];
8834  hid_t item_type1elem;
8835  item_type1elem=CreateFLStrType(shape[1]);
8836  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8837  dst_sizes[i]=((shape[1])*shape[0]);
8838  field_types[i]=item_type0;
8839  opened_types_.insert(field_types[i]);
8840 
8841  }
8842 
8843  }else if(valtype==typeid(std::list<cyclus::Blob>)){
8844  shape=shapes[i];
8845  if(shape.empty()||shape[0]<1&&shape[1]<1){
8846  dbtypes[i]=VL_LIST_BLOB;
8847  hid_t item_type0;
8848  hid_t item_type1elem;
8849  item_type1elem=sha1_type_;
8850  item_type0=sha1_type_;
8851  if(vldts_.count(VL_LIST_BLOB)==0){
8852  vldts_[VL_LIST_BLOB]=H5Tvlen_create(item_type1elem);
8853  opened_types_.insert(vldts_[VL_LIST_BLOB]);
8854 
8855  }
8856  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8857  field_types[i]=sha1_type_;
8858 
8859  }else{
8860  dbtypes[i]=LIST_BLOB;
8861  hid_t item_type0;
8862  hsize_t shape01=shape[0];
8863  hid_t item_type1elem;
8864  item_type1elem=sha1_type_;
8865  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8866  dst_sizes[i]=((CYCLUS_SHA1_SIZE)*shape[0]);
8867  field_types[i]=item_type0;
8868  opened_types_.insert(field_types[i]);
8869 
8870  }
8871 
8872  }else if(valtype==typeid(std::list<boost::uuids::uuid>)){
8873  shape=shapes[i];
8874  if(shape.empty()||shape[0]<1){
8875  dbtypes[i]=VL_LIST_UUID;
8876  hid_t item_type0;
8877  hid_t item_type1elem;
8878  item_type1elem=uuid_type_;
8879  item_type0=sha1_type_;
8880  if(vldts_.count(VL_LIST_UUID)==0){
8881  vldts_[VL_LIST_UUID]=H5Tvlen_create(item_type1elem);
8882  opened_types_.insert(vldts_[VL_LIST_UUID]);
8883 
8884  }
8885  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
8886  field_types[i]=sha1_type_;
8887 
8888  }else{
8889  dbtypes[i]=LIST_UUID;
8890  hid_t item_type0;
8891  hsize_t shape01=shape[0];
8892  hid_t item_type1elem;
8893  item_type1elem=uuid_type_;
8894  item_type0=H5Tarray_create2(item_type1elem, 1, &shape01);
8895  dst_sizes[i]=((CYCLUS_UUID_SIZE)*shape[0]);
8896  field_types[i]=item_type0;
8897  opened_types_.insert(field_types[i]);
8898 
8899  }
8900 
8901  }else if(valtype==typeid(std::pair<int, bool>)){
8902  shape=shapes[i];
8903  dbtypes[i]=PAIR_INT_BOOL;
8904  hid_t item_type0;
8905  hid_t item_type1first;
8906  item_type1first=H5T_NATIVE_INT;
8907  hid_t item_type1second;
8908  item_type1second=H5T_NATIVE_CHAR;
8909  hid_t item_type1compound;
8910  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(char));
8911  H5Tinsert(item_type1compound, "first", 0, item_type1first);
8912  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8913  dst_sizes[i]=((sizeof(int)+sizeof(char)));
8914  field_types[i]=item_type1compound;
8915  opened_types_.insert(field_types[i]);
8916 
8917  }else if(valtype==typeid(std::pair<int, int>)){
8918  shape=shapes[i];
8919  dbtypes[i]=PAIR_INT_INT;
8920  hid_t item_type0;
8921  hid_t item_type1first;
8922  item_type1first=H5T_NATIVE_INT;
8923  hid_t item_type1second;
8924  item_type1second=H5T_NATIVE_INT;
8925  hid_t item_type1compound;
8926  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
8927  H5Tinsert(item_type1compound, "first", 0, item_type1first);
8928  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8929  dst_sizes[i]=((sizeof(int)+sizeof(int)));
8930  field_types[i]=item_type1compound;
8931  opened_types_.insert(field_types[i]);
8932 
8933  }else if(valtype==typeid(std::pair<int, float>)){
8934  shape=shapes[i];
8935  dbtypes[i]=PAIR_INT_FLOAT;
8936  hid_t item_type0;
8937  hid_t item_type1first;
8938  item_type1first=H5T_NATIVE_INT;
8939  hid_t item_type1second;
8940  item_type1second=H5T_NATIVE_FLOAT;
8941  hid_t item_type1compound;
8942  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(float));
8943  H5Tinsert(item_type1compound, "first", 0, item_type1first);
8944  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8945  dst_sizes[i]=((sizeof(int)+sizeof(float)));
8946  field_types[i]=item_type1compound;
8947  opened_types_.insert(field_types[i]);
8948 
8949  }else if(valtype==typeid(std::pair<int, double>)){
8950  shape=shapes[i];
8951  dbtypes[i]=PAIR_INT_DOUBLE;
8952  hid_t item_type0;
8953  hid_t item_type1first;
8954  item_type1first=H5T_NATIVE_INT;
8955  hid_t item_type1second;
8956  item_type1second=H5T_NATIVE_DOUBLE;
8957  hid_t item_type1compound;
8958  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
8959  H5Tinsert(item_type1compound, "first", 0, item_type1first);
8960  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8961  dst_sizes[i]=((sizeof(int)+sizeof(double)));
8962  field_types[i]=item_type1compound;
8963  opened_types_.insert(field_types[i]);
8964 
8965  }else if(valtype==typeid(std::pair<int, std::string>)){
8966  shape=shapes[i];
8967  if(shape.empty()||shape[2]<1){
8968  dbtypes[i]=PAIR_INT_VL_STRING;
8969  hid_t item_type0;
8970  hid_t item_type1first;
8971  item_type1first=H5T_NATIVE_INT;
8972  hid_t item_type1second;
8973  item_type1second=sha1_type_;
8974  hid_t item_type1compound;
8975  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
8976  H5Tinsert(item_type1compound, "first", 0, item_type1first);
8977  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8978  dst_sizes[i]=((sizeof(int)+CYCLUS_SHA1_SIZE));
8979  field_types[i]=item_type1compound;
8980  opened_types_.insert(field_types[i]);
8981 
8982  }else{
8983  dbtypes[i]=PAIR_INT_STRING;
8984  hid_t item_type0;
8985  hid_t item_type1first;
8986  item_type1first=H5T_NATIVE_INT;
8987  hid_t item_type1second;
8988  item_type1second=CreateFLStrType(shape[2]);
8989  hid_t item_type1compound;
8990  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+shape[2]);
8991  H5Tinsert(item_type1compound, "first", 0, item_type1first);
8992  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
8993  dst_sizes[i]=((sizeof(int)+shape[2]));
8994  field_types[i]=item_type1compound;
8995  opened_types_.insert(field_types[i]);
8996 
8997  }
8998 
8999  }else if(valtype==typeid(std::pair<int, cyclus::Blob>)){
9000  shape=shapes[i];
9001  dbtypes[i]=PAIR_INT_BLOB;
9002  hid_t item_type0;
9003  hid_t item_type1first;
9004  item_type1first=H5T_NATIVE_INT;
9005  hid_t item_type1second;
9006  item_type1second=sha1_type_;
9007  hid_t item_type1compound;
9008  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9009  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9010  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
9011  dst_sizes[i]=((sizeof(int)+CYCLUS_SHA1_SIZE));
9012  field_types[i]=item_type1compound;
9013  opened_types_.insert(field_types[i]);
9014 
9015  }else if(valtype==typeid(std::pair<int, boost::uuids::uuid>)){
9016  shape=shapes[i];
9017  dbtypes[i]=PAIR_INT_UUID;
9018  hid_t item_type0;
9019  hid_t item_type1first;
9020  item_type1first=H5T_NATIVE_INT;
9021  hid_t item_type1second;
9022  item_type1second=uuid_type_;
9023  hid_t item_type1compound;
9024  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_UUID_SIZE);
9025  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9026  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type1second);
9027  dst_sizes[i]=((sizeof(int)+CYCLUS_UUID_SIZE));
9028  field_types[i]=item_type1compound;
9029  opened_types_.insert(field_types[i]);
9030 
9031  }else if(valtype==typeid(std::pair<std::string, bool>)){
9032  shape=shapes[i];
9033  if(shape.empty()||shape[1]<1){
9034  dbtypes[i]=PAIR_VL_STRING_BOOL;
9035  hid_t item_type0;
9036  hid_t item_type1first;
9037  item_type1first=sha1_type_;
9038  hid_t item_type1second;
9039  item_type1second=H5T_NATIVE_CHAR;
9040  hid_t item_type1compound;
9041  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(char));
9042  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9043  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9044  dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(char)));
9045  field_types[i]=item_type1compound;
9046  opened_types_.insert(field_types[i]);
9047 
9048  }else{
9049  dbtypes[i]=PAIR_STRING_BOOL;
9050  hid_t item_type0;
9051  hid_t item_type1first;
9052  item_type1first=CreateFLStrType(shape[1]);
9053  hid_t item_type1second;
9054  item_type1second=H5T_NATIVE_CHAR;
9055  hid_t item_type1compound;
9056  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(char));
9057  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9058  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9059  dst_sizes[i]=((shape[1]+sizeof(char)));
9060  field_types[i]=item_type1compound;
9061  opened_types_.insert(field_types[i]);
9062 
9063  }
9064 
9065  }else if(valtype==typeid(std::pair<std::string, int>)){
9066  shape=shapes[i];
9067  if(shape.empty()||shape[1]<1){
9068  dbtypes[i]=PAIR_VL_STRING_INT;
9069  hid_t item_type0;
9070  hid_t item_type1first;
9071  item_type1first=sha1_type_;
9072  hid_t item_type1second;
9073  item_type1second=H5T_NATIVE_INT;
9074  hid_t item_type1compound;
9075  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
9076  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9077  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9078  dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(int)));
9079  field_types[i]=item_type1compound;
9080  opened_types_.insert(field_types[i]);
9081 
9082  }else{
9083  dbtypes[i]=PAIR_STRING_INT;
9084  hid_t item_type0;
9085  hid_t item_type1first;
9086  item_type1first=CreateFLStrType(shape[1]);
9087  hid_t item_type1second;
9088  item_type1second=H5T_NATIVE_INT;
9089  hid_t item_type1compound;
9090  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(int));
9091  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9092  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9093  dst_sizes[i]=((shape[1]+sizeof(int)));
9094  field_types[i]=item_type1compound;
9095  opened_types_.insert(field_types[i]);
9096 
9097  }
9098 
9099  }else if(valtype==typeid(std::pair<std::string, float>)){
9100  shape=shapes[i];
9101  if(shape.empty()||shape[1]<1){
9102  dbtypes[i]=PAIR_VL_STRING_FLOAT;
9103  hid_t item_type0;
9104  hid_t item_type1first;
9105  item_type1first=sha1_type_;
9106  hid_t item_type1second;
9107  item_type1second=H5T_NATIVE_FLOAT;
9108  hid_t item_type1compound;
9109  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(float));
9110  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9111  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9112  dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(float)));
9113  field_types[i]=item_type1compound;
9114  opened_types_.insert(field_types[i]);
9115 
9116  }else{
9117  dbtypes[i]=PAIR_STRING_FLOAT;
9118  hid_t item_type0;
9119  hid_t item_type1first;
9120  item_type1first=CreateFLStrType(shape[1]);
9121  hid_t item_type1second;
9122  item_type1second=H5T_NATIVE_FLOAT;
9123  hid_t item_type1compound;
9124  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(float));
9125  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9126  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9127  dst_sizes[i]=((shape[1]+sizeof(float)));
9128  field_types[i]=item_type1compound;
9129  opened_types_.insert(field_types[i]);
9130 
9131  }
9132 
9133  }else if(valtype==typeid(std::pair<std::string, double>)){
9134  shape=shapes[i];
9135  if(shape.empty()||shape[1]<1){
9136  dbtypes[i]=PAIR_VL_STRING_DOUBLE;
9137  hid_t item_type0;
9138  hid_t item_type1first;
9139  item_type1first=sha1_type_;
9140  hid_t item_type1second;
9141  item_type1second=H5T_NATIVE_DOUBLE;
9142  hid_t item_type1compound;
9143  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
9144  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9145  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9146  dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(double)));
9147  field_types[i]=item_type1compound;
9148  opened_types_.insert(field_types[i]);
9149 
9150  }else{
9151  dbtypes[i]=PAIR_STRING_DOUBLE;
9152  hid_t item_type0;
9153  hid_t item_type1first;
9154  item_type1first=CreateFLStrType(shape[1]);
9155  hid_t item_type1second;
9156  item_type1second=H5T_NATIVE_DOUBLE;
9157  hid_t item_type1compound;
9158  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(double));
9159  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9160  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9161  dst_sizes[i]=((shape[1]+sizeof(double)));
9162  field_types[i]=item_type1compound;
9163  opened_types_.insert(field_types[i]);
9164 
9165  }
9166 
9167  }else if(valtype==typeid(std::pair<std::string, std::string>)){
9168  shape=shapes[i];
9169  if(shape.empty()||shape[1]<1&&shape[2]<1){
9170  dbtypes[i]=PAIR_VL_STRING_VL_STRING;
9171  hid_t item_type0;
9172  hid_t item_type1first;
9173  item_type1first=sha1_type_;
9174  hid_t item_type1second;
9175  item_type1second=sha1_type_;
9176  hid_t item_type1compound;
9177  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
9178  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9179  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9180  dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
9181  field_types[i]=item_type1compound;
9182  opened_types_.insert(field_types[i]);
9183 
9184  }else if(shape[1]>=1&&shape[2]<1){
9185  dbtypes[i]=PAIR_STRING_VL_STRING;
9186  hid_t item_type0;
9187  hid_t item_type1first;
9188  item_type1first=CreateFLStrType(shape[1]);
9189  hid_t item_type1second;
9190  item_type1second=sha1_type_;
9191  hid_t item_type1compound;
9192  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_SHA1_SIZE);
9193  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9194  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9195  dst_sizes[i]=((shape[1]+CYCLUS_SHA1_SIZE));
9196  field_types[i]=item_type1compound;
9197  opened_types_.insert(field_types[i]);
9198 
9199  }else if(shape[1]<1&&shape[2]>=1){
9200  dbtypes[i]=PAIR_VL_STRING_STRING;
9201  hid_t item_type0;
9202  hid_t item_type1first;
9203  item_type1first=sha1_type_;
9204  hid_t item_type1second;
9205  item_type1second=CreateFLStrType(shape[2]);
9206  hid_t item_type1compound;
9207  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[2]);
9208  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9209  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9210  dst_sizes[i]=((CYCLUS_SHA1_SIZE+shape[2]));
9211  field_types[i]=item_type1compound;
9212  opened_types_.insert(field_types[i]);
9213 
9214  }else{
9215  dbtypes[i]=PAIR_STRING_STRING;
9216  hid_t item_type0;
9217  hid_t item_type1first;
9218  item_type1first=CreateFLStrType(shape[1]);
9219  hid_t item_type1second;
9220  item_type1second=CreateFLStrType(shape[2]);
9221  hid_t item_type1compound;
9222  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+shape[2]);
9223  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9224  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9225  dst_sizes[i]=((shape[1]+shape[2]));
9226  field_types[i]=item_type1compound;
9227  opened_types_.insert(field_types[i]);
9228 
9229  }
9230 
9231  }else if(valtype==typeid(std::pair<std::string, cyclus::Blob>)){
9232  shape=shapes[i];
9233  if(shape.empty()||shape[1]<1&&shape[2]<1){
9234  dbtypes[i]=PAIR_VL_STRING_BLOB;
9235  hid_t item_type0;
9236  hid_t item_type1first;
9237  item_type1first=sha1_type_;
9238  hid_t item_type1second;
9239  item_type1second=sha1_type_;
9240  hid_t item_type1compound;
9241  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
9242  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9243  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9244  dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
9245  field_types[i]=item_type1compound;
9246  opened_types_.insert(field_types[i]);
9247 
9248  }else{
9249  dbtypes[i]=PAIR_STRING_BLOB;
9250  hid_t item_type0;
9251  hid_t item_type1first;
9252  item_type1first=CreateFLStrType(shape[1]);
9253  hid_t item_type1second;
9254  item_type1second=sha1_type_;
9255  hid_t item_type1compound;
9256  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_SHA1_SIZE);
9257  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9258  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9259  dst_sizes[i]=((shape[1]+CYCLUS_SHA1_SIZE));
9260  field_types[i]=item_type1compound;
9261  opened_types_.insert(field_types[i]);
9262 
9263  }
9264 
9265  }else if(valtype==typeid(std::pair<std::string, boost::uuids::uuid>)){
9266  shape=shapes[i];
9267  if(shape.empty()||shape[1]<1){
9268  dbtypes[i]=PAIR_VL_STRING_UUID;
9269  hid_t item_type0;
9270  hid_t item_type1first;
9271  item_type1first=sha1_type_;
9272  hid_t item_type1second;
9273  item_type1second=uuid_type_;
9274  hid_t item_type1compound;
9275  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE);
9276  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9277  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
9278  dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE));
9279  field_types[i]=item_type1compound;
9280  opened_types_.insert(field_types[i]);
9281 
9282  }else{
9283  dbtypes[i]=PAIR_STRING_UUID;
9284  hid_t item_type0;
9285  hid_t item_type1first;
9286  item_type1first=CreateFLStrType(shape[1]);
9287  hid_t item_type1second;
9288  item_type1second=uuid_type_;
9289  hid_t item_type1compound;
9290  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_UUID_SIZE);
9291  H5Tinsert(item_type1compound, "first", 0, item_type1first);
9292  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
9293  dst_sizes[i]=((shape[1]+CYCLUS_UUID_SIZE));
9294  field_types[i]=item_type1compound;
9295  opened_types_.insert(field_types[i]);
9296 
9297  }
9298 
9299  }else if(valtype==typeid(std::map<int, bool>)){
9300  shape=shapes[i];
9301  if(shape.empty()||shape[0]<1){
9302  dbtypes[i]=VL_MAP_INT_BOOL;
9303  hid_t item_type0;
9304  hid_t item_type1key;
9305  item_type1key=H5T_NATIVE_INT;
9306  hid_t item_type1val;
9307  item_type1val=H5T_NATIVE_CHAR;
9308  hid_t item_type1compound;
9309  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(char));
9310  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9311  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9312  item_type0=sha1_type_;
9313  if(vldts_.count(VL_MAP_INT_BOOL)==0){
9314  vldts_[VL_MAP_INT_BOOL]=H5Tvlen_create(item_type1compound);
9315  opened_types_.insert(vldts_[VL_MAP_INT_BOOL]);
9316 
9317  }
9318  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9319  field_types[i]=sha1_type_;
9320 
9321  }else{
9322  dbtypes[i]=MAP_INT_BOOL;
9323  hid_t item_type0;
9324  hsize_t shape01=shape[0];
9325  hid_t item_type1key;
9326  item_type1key=H5T_NATIVE_INT;
9327  hid_t item_type1val;
9328  item_type1val=H5T_NATIVE_CHAR;
9329  hid_t item_type1compound;
9330  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(char));
9331  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9332  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9333  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9334  dst_sizes[i]=((sizeof(int)+sizeof(char))*shape[0]);
9335  field_types[i]=item_type0;
9336  opened_types_.insert(item_type1compound);
9337  opened_types_.insert(field_types[i]);
9338 
9339  }
9340 
9341  }else if(valtype==typeid(std::map<int, int>)){
9342  shape=shapes[i];
9343  if(shape.empty()||shape[0]<1){
9344  dbtypes[i]=VL_MAP_INT_INT;
9345  hid_t item_type0;
9346  hid_t item_type1key;
9347  item_type1key=H5T_NATIVE_INT;
9348  hid_t item_type1val;
9349  item_type1val=H5T_NATIVE_INT;
9350  hid_t item_type1compound;
9351  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
9352  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9353  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9354  item_type0=sha1_type_;
9355  if(vldts_.count(VL_MAP_INT_INT)==0){
9356  vldts_[VL_MAP_INT_INT]=H5Tvlen_create(item_type1compound);
9357  opened_types_.insert(vldts_[VL_MAP_INT_INT]);
9358 
9359  }
9360  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9361  field_types[i]=sha1_type_;
9362 
9363  }else{
9364  dbtypes[i]=MAP_INT_INT;
9365  hid_t item_type0;
9366  hsize_t shape01=shape[0];
9367  hid_t item_type1key;
9368  item_type1key=H5T_NATIVE_INT;
9369  hid_t item_type1val;
9370  item_type1val=H5T_NATIVE_INT;
9371  hid_t item_type1compound;
9372  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
9373  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9374  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9375  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9376  dst_sizes[i]=((sizeof(int)+sizeof(int))*shape[0]);
9377  field_types[i]=item_type0;
9378  opened_types_.insert(item_type1compound);
9379  opened_types_.insert(field_types[i]);
9380 
9381  }
9382 
9383  }else if(valtype==typeid(std::map<int, float>)){
9384  shape=shapes[i];
9385  if(shape.empty()||shape[0]<1){
9386  dbtypes[i]=VL_MAP_INT_FLOAT;
9387  hid_t item_type0;
9388  hid_t item_type1key;
9389  item_type1key=H5T_NATIVE_INT;
9390  hid_t item_type1val;
9391  item_type1val=H5T_NATIVE_FLOAT;
9392  hid_t item_type1compound;
9393  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(float));
9394  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9395  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9396  item_type0=sha1_type_;
9397  if(vldts_.count(VL_MAP_INT_FLOAT)==0){
9398  vldts_[VL_MAP_INT_FLOAT]=H5Tvlen_create(item_type1compound);
9399  opened_types_.insert(vldts_[VL_MAP_INT_FLOAT]);
9400 
9401  }
9402  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9403  field_types[i]=sha1_type_;
9404 
9405  }else{
9406  dbtypes[i]=MAP_INT_FLOAT;
9407  hid_t item_type0;
9408  hsize_t shape01=shape[0];
9409  hid_t item_type1key;
9410  item_type1key=H5T_NATIVE_INT;
9411  hid_t item_type1val;
9412  item_type1val=H5T_NATIVE_FLOAT;
9413  hid_t item_type1compound;
9414  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(float));
9415  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9416  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9417  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9418  dst_sizes[i]=((sizeof(int)+sizeof(float))*shape[0]);
9419  field_types[i]=item_type0;
9420  opened_types_.insert(item_type1compound);
9421  opened_types_.insert(field_types[i]);
9422 
9423  }
9424 
9425  }else if(valtype==typeid(std::map<int, double>)){
9426  shape=shapes[i];
9427  if(shape.empty()||shape[0]<1){
9428  dbtypes[i]=VL_MAP_INT_DOUBLE;
9429  hid_t item_type0;
9430  hid_t item_type1key;
9431  item_type1key=H5T_NATIVE_INT;
9432  hid_t item_type1val;
9433  item_type1val=H5T_NATIVE_DOUBLE;
9434  hid_t item_type1compound;
9435  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
9436  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9437  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9438  item_type0=sha1_type_;
9439  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
9440  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
9441  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
9442 
9443  }
9444  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9445  field_types[i]=sha1_type_;
9446 
9447  }else{
9448  dbtypes[i]=MAP_INT_DOUBLE;
9449  hid_t item_type0;
9450  hsize_t shape01=shape[0];
9451  hid_t item_type1key;
9452  item_type1key=H5T_NATIVE_INT;
9453  hid_t item_type1val;
9454  item_type1val=H5T_NATIVE_DOUBLE;
9455  hid_t item_type1compound;
9456  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
9457  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9458  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9459  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9460  dst_sizes[i]=((sizeof(int)+sizeof(double))*shape[0]);
9461  field_types[i]=item_type0;
9462  opened_types_.insert(item_type1compound);
9463  opened_types_.insert(field_types[i]);
9464 
9465  }
9466 
9467  }else if(valtype==typeid(std::map<int, std::string>)){
9468  shape=shapes[i];
9469  if(shape.empty()||shape[0]<1&&shape[2]<1){
9470  dbtypes[i]=VL_MAP_INT_VL_STRING;
9471  hid_t item_type0;
9472  hid_t item_type1key;
9473  item_type1key=H5T_NATIVE_INT;
9474  hid_t item_type1val;
9475  item_type1val=sha1_type_;
9476  hid_t item_type1compound;
9477  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9478  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9479  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9480  item_type0=sha1_type_;
9481  if(vldts_.count(VL_MAP_INT_VL_STRING)==0){
9482  vldts_[VL_MAP_INT_VL_STRING]=H5Tvlen_create(item_type1compound);
9483  opened_types_.insert(vldts_[VL_MAP_INT_VL_STRING]);
9484 
9485  }
9486  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9487  field_types[i]=sha1_type_;
9488 
9489  }else if(shape[0]<1&&shape[2]>=1){
9490  dbtypes[i]=VL_MAP_INT_STRING;
9491  hid_t item_type0;
9492  hid_t item_type1key;
9493  item_type1key=H5T_NATIVE_INT;
9494  hid_t item_type1val;
9495  item_type1val=sha1_type_;
9496  hid_t item_type1compound;
9497  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9498  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9499  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9500  item_type0=sha1_type_;
9501  if(vldts_.count(VL_MAP_INT_STRING)==0){
9502  vldts_[VL_MAP_INT_STRING]=H5Tvlen_create(item_type1compound);
9503  opened_types_.insert(vldts_[VL_MAP_INT_STRING]);
9504 
9505  }
9506  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9507  field_types[i]=sha1_type_;
9508 
9509  }else if(shape[0]>=1&&shape[2]<1){
9510  dbtypes[i]=MAP_INT_VL_STRING;
9511  hid_t item_type0;
9512  hsize_t shape01=shape[0];
9513  hid_t item_type1key;
9514  item_type1key=H5T_NATIVE_INT;
9515  hid_t item_type1val;
9516  item_type1val=sha1_type_;
9517  hid_t item_type1compound;
9518  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9519  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9520  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9521  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9522  dst_sizes[i]=((sizeof(int)+CYCLUS_SHA1_SIZE)*shape[0]);
9523  field_types[i]=item_type0;
9524  opened_types_.insert(item_type1compound);
9525  opened_types_.insert(field_types[i]);
9526 
9527  }else{
9528  dbtypes[i]=MAP_INT_STRING;
9529  hid_t item_type0;
9530  hsize_t shape01=shape[0];
9531  hid_t item_type1key;
9532  item_type1key=H5T_NATIVE_INT;
9533  hid_t item_type1val;
9534  item_type1val=CreateFLStrType(shape[2]);
9535  hid_t item_type1compound;
9536  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+shape[2]);
9537  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9538  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9539  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9540  dst_sizes[i]=((sizeof(int)+shape[2])*shape[0]);
9541  field_types[i]=item_type0;
9542  opened_types_.insert(item_type1compound);
9543  opened_types_.insert(field_types[i]);
9544 
9545  }
9546 
9547  }else if(valtype==typeid(std::map<int, cyclus::Blob>)){
9548  shape=shapes[i];
9549  if(shape.empty()||shape[0]<1&&shape[2]<1){
9550  dbtypes[i]=VL_MAP_INT_BLOB;
9551  hid_t item_type0;
9552  hid_t item_type1key;
9553  item_type1key=H5T_NATIVE_INT;
9554  hid_t item_type1val;
9555  item_type1val=sha1_type_;
9556  hid_t item_type1compound;
9557  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9558  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9559  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9560  item_type0=sha1_type_;
9561  if(vldts_.count(VL_MAP_INT_BLOB)==0){
9562  vldts_[VL_MAP_INT_BLOB]=H5Tvlen_create(item_type1compound);
9563  opened_types_.insert(vldts_[VL_MAP_INT_BLOB]);
9564 
9565  }
9566  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9567  field_types[i]=sha1_type_;
9568 
9569  }else{
9570  dbtypes[i]=MAP_INT_BLOB;
9571  hid_t item_type0;
9572  hsize_t shape01=shape[0];
9573  hid_t item_type1key;
9574  item_type1key=H5T_NATIVE_INT;
9575  hid_t item_type1val;
9576  item_type1val=sha1_type_;
9577  hid_t item_type1compound;
9578  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
9579  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9580  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9581  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9582  dst_sizes[i]=((sizeof(int)+CYCLUS_SHA1_SIZE)*shape[0]);
9583  field_types[i]=item_type0;
9584  opened_types_.insert(item_type1compound);
9585  opened_types_.insert(field_types[i]);
9586 
9587  }
9588 
9589  }else if(valtype==typeid(std::map<int, boost::uuids::uuid>)){
9590  shape=shapes[i];
9591  if(shape.empty()||shape[0]<1){
9592  dbtypes[i]=VL_MAP_INT_UUID;
9593  hid_t item_type0;
9594  hid_t item_type1key;
9595  item_type1key=H5T_NATIVE_INT;
9596  hid_t item_type1val;
9597  item_type1val=uuid_type_;
9598  hid_t item_type1compound;
9599  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_UUID_SIZE);
9600  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9601  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9602  item_type0=sha1_type_;
9603  if(vldts_.count(VL_MAP_INT_UUID)==0){
9604  vldts_[VL_MAP_INT_UUID]=H5Tvlen_create(item_type1compound);
9605  opened_types_.insert(vldts_[VL_MAP_INT_UUID]);
9606 
9607  }
9608  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9609  field_types[i]=sha1_type_;
9610 
9611  }else{
9612  dbtypes[i]=MAP_INT_UUID;
9613  hid_t item_type0;
9614  hsize_t shape01=shape[0];
9615  hid_t item_type1key;
9616  item_type1key=H5T_NATIVE_INT;
9617  hid_t item_type1val;
9618  item_type1val=uuid_type_;
9619  hid_t item_type1compound;
9620  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_UUID_SIZE);
9621  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9622  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
9623  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9624  dst_sizes[i]=((sizeof(int)+CYCLUS_UUID_SIZE)*shape[0]);
9625  field_types[i]=item_type0;
9626  opened_types_.insert(item_type1compound);
9627  opened_types_.insert(field_types[i]);
9628 
9629  }
9630 
9631  }else if(valtype==typeid(std::map<std::string, bool>)){
9632  shape=shapes[i];
9633  if(shape.empty()||shape[0]<1&&shape[1]<1){
9634  dbtypes[i]=VL_MAP_VL_STRING_BOOL;
9635  hid_t item_type0;
9636  hid_t item_type1key;
9637  item_type1key=sha1_type_;
9638  hid_t item_type1val;
9639  item_type1val=H5T_NATIVE_CHAR;
9640  hid_t item_type1compound;
9641  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(char));
9642  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9643  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9644  item_type0=sha1_type_;
9645  if(vldts_.count(VL_MAP_VL_STRING_BOOL)==0){
9646  vldts_[VL_MAP_VL_STRING_BOOL]=H5Tvlen_create(item_type1compound);
9647  opened_types_.insert(vldts_[VL_MAP_VL_STRING_BOOL]);
9648 
9649  }
9650  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9651  field_types[i]=sha1_type_;
9652 
9653  }else if(shape[0]<1&&shape[1]>=1){
9654  dbtypes[i]=VL_MAP_STRING_BOOL;
9655  hid_t item_type0;
9656  hid_t item_type1key;
9657  item_type1key=sha1_type_;
9658  hid_t item_type1val;
9659  item_type1val=H5T_NATIVE_CHAR;
9660  hid_t item_type1compound;
9661  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(char));
9662  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9663  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9664  item_type0=sha1_type_;
9665  if(vldts_.count(VL_MAP_STRING_BOOL)==0){
9666  vldts_[VL_MAP_STRING_BOOL]=H5Tvlen_create(item_type1compound);
9667  opened_types_.insert(vldts_[VL_MAP_STRING_BOOL]);
9668 
9669  }
9670  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9671  field_types[i]=sha1_type_;
9672 
9673  }else if(shape[0]>=1&&shape[1]<1){
9674  dbtypes[i]=MAP_VL_STRING_BOOL;
9675  hid_t item_type0;
9676  hsize_t shape01=shape[0];
9677  hid_t item_type1key;
9678  item_type1key=sha1_type_;
9679  hid_t item_type1val;
9680  item_type1val=H5T_NATIVE_CHAR;
9681  hid_t item_type1compound;
9682  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(char));
9683  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9684  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9685  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9686  dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(char))*shape[0]);
9687  field_types[i]=item_type0;
9688  opened_types_.insert(item_type1compound);
9689  opened_types_.insert(field_types[i]);
9690 
9691  }else{
9692  dbtypes[i]=MAP_STRING_BOOL;
9693  hid_t item_type0;
9694  hsize_t shape01=shape[0];
9695  hid_t item_type1key;
9696  item_type1key=CreateFLStrType(shape[1]);
9697  hid_t item_type1val;
9698  item_type1val=H5T_NATIVE_CHAR;
9699  hid_t item_type1compound;
9700  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(char));
9701  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9702  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
9703  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9704  dst_sizes[i]=((shape[1]+sizeof(char))*shape[0]);
9705  field_types[i]=item_type0;
9706  opened_types_.insert(item_type1compound);
9707  opened_types_.insert(field_types[i]);
9708 
9709  }
9710 
9711  }else if(valtype==typeid(std::map<std::string, int>)){
9712  shape=shapes[i];
9713  if(shape.empty()||shape[0]<1&&shape[1]<1){
9714  dbtypes[i]=VL_MAP_VL_STRING_INT;
9715  hid_t item_type0;
9716  hid_t item_type1key;
9717  item_type1key=sha1_type_;
9718  hid_t item_type1val;
9719  item_type1val=H5T_NATIVE_INT;
9720  hid_t item_type1compound;
9721  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
9722  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9723  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9724  item_type0=sha1_type_;
9725  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
9726  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
9727  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
9728 
9729  }
9730  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9731  field_types[i]=sha1_type_;
9732 
9733  }else if(shape[0]<1&&shape[1]>=1){
9734  dbtypes[i]=VL_MAP_STRING_INT;
9735  hid_t item_type0;
9736  hid_t item_type1key;
9737  item_type1key=sha1_type_;
9738  hid_t item_type1val;
9739  item_type1val=H5T_NATIVE_INT;
9740  hid_t item_type1compound;
9741  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
9742  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9743  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9744  item_type0=sha1_type_;
9745  if(vldts_.count(VL_MAP_STRING_INT)==0){
9746  vldts_[VL_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
9747  opened_types_.insert(vldts_[VL_MAP_STRING_INT]);
9748 
9749  }
9750  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9751  field_types[i]=sha1_type_;
9752 
9753  }else if(shape[0]>=1&&shape[1]<1){
9754  dbtypes[i]=MAP_VL_STRING_INT;
9755  hid_t item_type0;
9756  hsize_t shape01=shape[0];
9757  hid_t item_type1key;
9758  item_type1key=sha1_type_;
9759  hid_t item_type1val;
9760  item_type1val=H5T_NATIVE_INT;
9761  hid_t item_type1compound;
9762  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
9763  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9764  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9765  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9766  dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[0]);
9767  field_types[i]=item_type0;
9768  opened_types_.insert(item_type1compound);
9769  opened_types_.insert(field_types[i]);
9770 
9771  }else{
9772  dbtypes[i]=MAP_STRING_INT;
9773  hid_t item_type0;
9774  hsize_t shape01=shape[0];
9775  hid_t item_type1key;
9776  item_type1key=CreateFLStrType(shape[1]);
9777  hid_t item_type1val;
9778  item_type1val=H5T_NATIVE_INT;
9779  hid_t item_type1compound;
9780  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(int));
9781  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9782  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
9783  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9784  dst_sizes[i]=((shape[1]+sizeof(int))*shape[0]);
9785  field_types[i]=item_type0;
9786  opened_types_.insert(item_type1compound);
9787  opened_types_.insert(field_types[i]);
9788 
9789  }
9790 
9791  }else if(valtype==typeid(std::map<std::string, float>)){
9792  shape=shapes[i];
9793  if(shape.empty()||shape[0]<1&&shape[1]<1){
9794  dbtypes[i]=VL_MAP_VL_STRING_FLOAT;
9795  hid_t item_type0;
9796  hid_t item_type1key;
9797  item_type1key=sha1_type_;
9798  hid_t item_type1val;
9799  item_type1val=H5T_NATIVE_FLOAT;
9800  hid_t item_type1compound;
9801  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(float));
9802  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9803  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9804  item_type0=sha1_type_;
9805  if(vldts_.count(VL_MAP_VL_STRING_FLOAT)==0){
9806  vldts_[VL_MAP_VL_STRING_FLOAT]=H5Tvlen_create(item_type1compound);
9807  opened_types_.insert(vldts_[VL_MAP_VL_STRING_FLOAT]);
9808 
9809  }
9810  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9811  field_types[i]=sha1_type_;
9812 
9813  }else if(shape[0]<1&&shape[1]>=1){
9814  dbtypes[i]=VL_MAP_STRING_FLOAT;
9815  hid_t item_type0;
9816  hid_t item_type1key;
9817  item_type1key=sha1_type_;
9818  hid_t item_type1val;
9819  item_type1val=H5T_NATIVE_FLOAT;
9820  hid_t item_type1compound;
9821  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(float));
9822  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9823  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9824  item_type0=sha1_type_;
9825  if(vldts_.count(VL_MAP_STRING_FLOAT)==0){
9826  vldts_[VL_MAP_STRING_FLOAT]=H5Tvlen_create(item_type1compound);
9827  opened_types_.insert(vldts_[VL_MAP_STRING_FLOAT]);
9828 
9829  }
9830  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9831  field_types[i]=sha1_type_;
9832 
9833  }else if(shape[0]>=1&&shape[1]<1){
9834  dbtypes[i]=MAP_VL_STRING_FLOAT;
9835  hid_t item_type0;
9836  hsize_t shape01=shape[0];
9837  hid_t item_type1key;
9838  item_type1key=sha1_type_;
9839  hid_t item_type1val;
9840  item_type1val=H5T_NATIVE_FLOAT;
9841  hid_t item_type1compound;
9842  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(float));
9843  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9844  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9845  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9846  dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(float))*shape[0]);
9847  field_types[i]=item_type0;
9848  opened_types_.insert(item_type1compound);
9849  opened_types_.insert(field_types[i]);
9850 
9851  }else{
9852  dbtypes[i]=MAP_STRING_FLOAT;
9853  hid_t item_type0;
9854  hsize_t shape01=shape[0];
9855  hid_t item_type1key;
9856  item_type1key=CreateFLStrType(shape[1]);
9857  hid_t item_type1val;
9858  item_type1val=H5T_NATIVE_FLOAT;
9859  hid_t item_type1compound;
9860  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(float));
9861  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9862  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
9863  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9864  dst_sizes[i]=((shape[1]+sizeof(float))*shape[0]);
9865  field_types[i]=item_type0;
9866  opened_types_.insert(item_type1compound);
9867  opened_types_.insert(field_types[i]);
9868 
9869  }
9870 
9871  }else if(valtype==typeid(std::map<std::string, double>)){
9872  shape=shapes[i];
9873  if(shape.empty()||shape[0]<1&&shape[1]<1){
9874  dbtypes[i]=VL_MAP_VL_STRING_DOUBLE;
9875  hid_t item_type0;
9876  hid_t item_type1key;
9877  item_type1key=sha1_type_;
9878  hid_t item_type1val;
9879  item_type1val=H5T_NATIVE_DOUBLE;
9880  hid_t item_type1compound;
9881  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
9882  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9883  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9884  item_type0=sha1_type_;
9885  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
9886  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
9887  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
9888 
9889  }
9890  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9891  field_types[i]=sha1_type_;
9892 
9893  }else if(shape[0]<1&&shape[1]>=1){
9894  dbtypes[i]=VL_MAP_STRING_DOUBLE;
9895  hid_t item_type0;
9896  hid_t item_type1key;
9897  item_type1key=sha1_type_;
9898  hid_t item_type1val;
9899  item_type1val=H5T_NATIVE_DOUBLE;
9900  hid_t item_type1compound;
9901  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
9902  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9903  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9904  item_type0=sha1_type_;
9905  if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
9906  vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
9907  opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
9908 
9909  }
9910  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9911  field_types[i]=sha1_type_;
9912 
9913  }else if(shape[0]>=1&&shape[1]<1){
9914  dbtypes[i]=MAP_VL_STRING_DOUBLE;
9915  hid_t item_type0;
9916  hsize_t shape01=shape[0];
9917  hid_t item_type1key;
9918  item_type1key=sha1_type_;
9919  hid_t item_type1val;
9920  item_type1val=H5T_NATIVE_DOUBLE;
9921  hid_t item_type1compound;
9922  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
9923  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9924  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9925  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9926  dst_sizes[i]=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[0]);
9927  field_types[i]=item_type0;
9928  opened_types_.insert(item_type1compound);
9929  opened_types_.insert(field_types[i]);
9930 
9931  }else{
9932  dbtypes[i]=MAP_STRING_DOUBLE;
9933  hid_t item_type0;
9934  hsize_t shape01=shape[0];
9935  hid_t item_type1key;
9936  item_type1key=CreateFLStrType(shape[1]);
9937  hid_t item_type1val;
9938  item_type1val=H5T_NATIVE_DOUBLE;
9939  hid_t item_type1compound;
9940  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+sizeof(double));
9941  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9942  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
9943  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
9944  dst_sizes[i]=((shape[1]+sizeof(double))*shape[0]);
9945  field_types[i]=item_type0;
9946  opened_types_.insert(item_type1compound);
9947  opened_types_.insert(field_types[i]);
9948 
9949  }
9950 
9951  }else if(valtype==typeid(std::map<std::string, std::string>)){
9952  shape=shapes[i];
9953  if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1){
9954  dbtypes[i]=VL_MAP_VL_STRING_VL_STRING;
9955  hid_t item_type0;
9956  hid_t item_type1key;
9957  item_type1key=sha1_type_;
9958  hid_t item_type1val;
9959  item_type1val=sha1_type_;
9960  hid_t item_type1compound;
9961  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
9962  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9963  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9964  item_type0=sha1_type_;
9965  if(vldts_.count(VL_MAP_VL_STRING_VL_STRING)==0){
9966  vldts_[VL_MAP_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
9967  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_STRING]);
9968 
9969  }
9970  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9971  field_types[i]=sha1_type_;
9972 
9973  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1){
9974  dbtypes[i]=VL_MAP_STRING_STRING;
9975  hid_t item_type0;
9976  hid_t item_type1key;
9977  item_type1key=sha1_type_;
9978  hid_t item_type1val;
9979  item_type1val=sha1_type_;
9980  hid_t item_type1compound;
9981  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
9982  H5Tinsert(item_type1compound, "key", 0, item_type1key);
9983  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
9984  item_type0=sha1_type_;
9985  if(vldts_.count(VL_MAP_STRING_STRING)==0){
9986  vldts_[VL_MAP_STRING_STRING]=H5Tvlen_create(item_type1compound);
9987  opened_types_.insert(vldts_[VL_MAP_STRING_STRING]);
9988 
9989  }
9990  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
9991  field_types[i]=sha1_type_;
9992 
9993  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1){
9994  dbtypes[i]=MAP_STRING_VL_STRING;
9995  hid_t item_type0;
9996  hsize_t shape01=shape[0];
9997  hid_t item_type1key;
9998  item_type1key=CreateFLStrType(shape[1]);
9999  hid_t item_type1val;
10000  item_type1val=sha1_type_;
10001  hid_t item_type1compound;
10002  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_SHA1_SIZE);
10003  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10004  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10005  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10006  dst_sizes[i]=((shape[1]+CYCLUS_SHA1_SIZE)*shape[0]);
10007  field_types[i]=item_type0;
10008  opened_types_.insert(item_type1compound);
10009  opened_types_.insert(field_types[i]);
10010 
10011  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1){
10012  dbtypes[i]=VL_MAP_STRING_VL_STRING;
10013  hid_t item_type0;
10014  hid_t item_type1key;
10015  item_type1key=sha1_type_;
10016  hid_t item_type1val;
10017  item_type1val=sha1_type_;
10018  hid_t item_type1compound;
10019  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10020  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10021  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10022  item_type0=sha1_type_;
10023  if(vldts_.count(VL_MAP_STRING_VL_STRING)==0){
10024  vldts_[VL_MAP_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
10025  opened_types_.insert(vldts_[VL_MAP_STRING_VL_STRING]);
10026 
10027  }
10028  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10029  field_types[i]=sha1_type_;
10030 
10031  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1){
10032  dbtypes[i]=MAP_VL_STRING_STRING;
10033  hid_t item_type0;
10034  hsize_t shape01=shape[0];
10035  hid_t item_type1key;
10036  item_type1key=sha1_type_;
10037  hid_t item_type1val;
10038  item_type1val=CreateFLStrType(shape[2]);
10039  hid_t item_type1compound;
10040  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[2]);
10041  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10042  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10043  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10044  dst_sizes[i]=((CYCLUS_SHA1_SIZE+shape[2])*shape[0]);
10045  field_types[i]=item_type0;
10046  opened_types_.insert(item_type1compound);
10047  opened_types_.insert(field_types[i]);
10048 
10049  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1){
10050  dbtypes[i]=VL_MAP_VL_STRING_STRING;
10051  hid_t item_type0;
10052  hid_t item_type1key;
10053  item_type1key=sha1_type_;
10054  hid_t item_type1val;
10055  item_type1val=sha1_type_;
10056  hid_t item_type1compound;
10057  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10058  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10059  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10060  item_type0=sha1_type_;
10061  if(vldts_.count(VL_MAP_VL_STRING_STRING)==0){
10062  vldts_[VL_MAP_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
10063  opened_types_.insert(vldts_[VL_MAP_VL_STRING_STRING]);
10064 
10065  }
10066  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10067  field_types[i]=sha1_type_;
10068 
10069  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1){
10070  dbtypes[i]=MAP_VL_STRING_VL_STRING;
10071  hid_t item_type0;
10072  hsize_t shape01=shape[0];
10073  hid_t item_type1key;
10074  item_type1key=sha1_type_;
10075  hid_t item_type1val;
10076  item_type1val=sha1_type_;
10077  hid_t item_type1compound;
10078  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10079  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10080  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10081  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10082  dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)*shape[0]);
10083  field_types[i]=item_type0;
10084  opened_types_.insert(item_type1compound);
10085  opened_types_.insert(field_types[i]);
10086 
10087  }else{
10088  dbtypes[i]=MAP_STRING_STRING;
10089  hid_t item_type0;
10090  hsize_t shape01=shape[0];
10091  hid_t item_type1key;
10092  item_type1key=CreateFLStrType(shape[1]);
10093  hid_t item_type1val;
10094  item_type1val=CreateFLStrType(shape[2]);
10095  hid_t item_type1compound;
10096  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+shape[2]);
10097  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10098  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10099  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10100  dst_sizes[i]=((shape[1]+shape[2])*shape[0]);
10101  field_types[i]=item_type0;
10102  opened_types_.insert(item_type1compound);
10103  opened_types_.insert(field_types[i]);
10104 
10105  }
10106 
10107  }else if(valtype==typeid(std::map<std::string, cyclus::Blob>)){
10108  shape=shapes[i];
10109  if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1){
10110  dbtypes[i]=VL_MAP_VL_STRING_BLOB;
10111  hid_t item_type0;
10112  hid_t item_type1key;
10113  item_type1key=sha1_type_;
10114  hid_t item_type1val;
10115  item_type1val=sha1_type_;
10116  hid_t item_type1compound;
10117  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10118  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10119  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10120  item_type0=sha1_type_;
10121  if(vldts_.count(VL_MAP_VL_STRING_BLOB)==0){
10122  vldts_[VL_MAP_VL_STRING_BLOB]=H5Tvlen_create(item_type1compound);
10123  opened_types_.insert(vldts_[VL_MAP_VL_STRING_BLOB]);
10124 
10125  }
10126  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10127  field_types[i]=sha1_type_;
10128 
10129  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1){
10130  dbtypes[i]=VL_MAP_STRING_BLOB;
10131  hid_t item_type0;
10132  hid_t item_type1key;
10133  item_type1key=sha1_type_;
10134  hid_t item_type1val;
10135  item_type1val=sha1_type_;
10136  hid_t item_type1compound;
10137  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10138  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10139  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10140  item_type0=sha1_type_;
10141  if(vldts_.count(VL_MAP_STRING_BLOB)==0){
10142  vldts_[VL_MAP_STRING_BLOB]=H5Tvlen_create(item_type1compound);
10143  opened_types_.insert(vldts_[VL_MAP_STRING_BLOB]);
10144 
10145  }
10146  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10147  field_types[i]=sha1_type_;
10148 
10149  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1){
10150  dbtypes[i]=MAP_VL_STRING_BLOB;
10151  hid_t item_type0;
10152  hsize_t shape01=shape[0];
10153  hid_t item_type1key;
10154  item_type1key=sha1_type_;
10155  hid_t item_type1val;
10156  item_type1val=sha1_type_;
10157  hid_t item_type1compound;
10158  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
10159  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10160  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10161  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10162  dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)*shape[0]);
10163  field_types[i]=item_type0;
10164  opened_types_.insert(item_type1compound);
10165  opened_types_.insert(field_types[i]);
10166 
10167  }else{
10168  dbtypes[i]=MAP_STRING_BLOB;
10169  hid_t item_type0;
10170  hsize_t shape01=shape[0];
10171  hid_t item_type1key;
10172  item_type1key=CreateFLStrType(shape[1]);
10173  hid_t item_type1val;
10174  item_type1val=sha1_type_;
10175  hid_t item_type1compound;
10176  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_SHA1_SIZE);
10177  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10178  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10179  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10180  dst_sizes[i]=((shape[1]+CYCLUS_SHA1_SIZE)*shape[0]);
10181  field_types[i]=item_type0;
10182  opened_types_.insert(item_type1compound);
10183  opened_types_.insert(field_types[i]);
10184 
10185  }
10186 
10187  }else if(valtype==typeid(std::map<std::string, boost::uuids::uuid>)){
10188  shape=shapes[i];
10189  if(shape.empty()||shape[0]<1&&shape[1]<1){
10190  dbtypes[i]=VL_MAP_VL_STRING_UUID;
10191  hid_t item_type0;
10192  hid_t item_type1key;
10193  item_type1key=sha1_type_;
10194  hid_t item_type1val;
10195  item_type1val=uuid_type_;
10196  hid_t item_type1compound;
10197  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE);
10198  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10199  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10200  item_type0=sha1_type_;
10201  if(vldts_.count(VL_MAP_VL_STRING_UUID)==0){
10202  vldts_[VL_MAP_VL_STRING_UUID]=H5Tvlen_create(item_type1compound);
10203  opened_types_.insert(vldts_[VL_MAP_VL_STRING_UUID]);
10204 
10205  }
10206  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10207  field_types[i]=sha1_type_;
10208 
10209  }else if(shape[0]<1&&shape[1]>=1){
10210  dbtypes[i]=VL_MAP_STRING_UUID;
10211  hid_t item_type0;
10212  hid_t item_type1key;
10213  item_type1key=sha1_type_;
10214  hid_t item_type1val;
10215  item_type1val=uuid_type_;
10216  hid_t item_type1compound;
10217  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE);
10218  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10219  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10220  item_type0=sha1_type_;
10221  if(vldts_.count(VL_MAP_STRING_UUID)==0){
10222  vldts_[VL_MAP_STRING_UUID]=H5Tvlen_create(item_type1compound);
10223  opened_types_.insert(vldts_[VL_MAP_STRING_UUID]);
10224 
10225  }
10226  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10227  field_types[i]=sha1_type_;
10228 
10229  }else if(shape[0]>=1&&shape[1]<1){
10230  dbtypes[i]=MAP_VL_STRING_UUID;
10231  hid_t item_type0;
10232  hsize_t shape01=shape[0];
10233  hid_t item_type1key;
10234  item_type1key=sha1_type_;
10235  hid_t item_type1val;
10236  item_type1val=uuid_type_;
10237  hid_t item_type1compound;
10238  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE);
10239  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10240  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10241  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10242  dst_sizes[i]=((CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE)*shape[0]);
10243  field_types[i]=item_type0;
10244  opened_types_.insert(item_type1compound);
10245  opened_types_.insert(field_types[i]);
10246 
10247  }else{
10248  dbtypes[i]=MAP_STRING_UUID;
10249  hid_t item_type0;
10250  hsize_t shape01=shape[0];
10251  hid_t item_type1key;
10252  item_type1key=CreateFLStrType(shape[1]);
10253  hid_t item_type1val;
10254  item_type1val=uuid_type_;
10255  hid_t item_type1compound;
10256  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+CYCLUS_UUID_SIZE);
10257  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10258  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10259  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10260  dst_sizes[i]=((shape[1]+CYCLUS_UUID_SIZE)*shape[0]);
10261  field_types[i]=item_type0;
10262  opened_types_.insert(item_type1compound);
10263  opened_types_.insert(field_types[i]);
10264 
10265  }
10266 
10267  }else if(valtype==typeid(std::map<std::pair<int, std::string>, double>)){
10268  shape=shapes[i];
10269  if(shape.empty()||shape[0]<1&&shape[3]<1){
10271  hid_t item_type0;
10272  hid_t item_type1key;
10273  hid_t item_type2first;
10274  item_type2first=H5T_NATIVE_INT;
10275  hid_t item_type2second;
10276  item_type2second=sha1_type_;
10277  hid_t item_type2keycompound;
10278  item_type2keycompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
10279  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
10280  H5Tinsert(item_type2keycompound, "second", 0+sizeof(int), item_type2second);
10281  hid_t item_type1val;
10282  item_type1val=H5T_NATIVE_DOUBLE;
10283  hid_t item_type1compound;
10284  item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double));
10285  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
10286  H5Tinsert(item_type1compound, "val", 0+((sizeof(int)+CYCLUS_SHA1_SIZE)), item_type1val);
10287  item_type0=sha1_type_;
10288  if(vldts_.count(VL_MAP_PAIR_INT_VL_STRING_DOUBLE)==0){
10289  vldts_[VL_MAP_PAIR_INT_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
10290  opened_types_.insert(vldts_[VL_MAP_PAIR_INT_VL_STRING_DOUBLE]);
10291 
10292  }
10293  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10294  field_types[i]=sha1_type_;
10295 
10296  }else if(shape[0]<1&&shape[3]>=1){
10297  dbtypes[i]=VL_MAP_PAIR_INT_STRING_DOUBLE;
10298  hid_t item_type0;
10299  hid_t item_type1key;
10300  hid_t item_type2first;
10301  item_type2first=H5T_NATIVE_INT;
10302  hid_t item_type2second;
10303  item_type2second=sha1_type_;
10304  hid_t item_type2keycompound;
10305  item_type2keycompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
10306  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
10307  H5Tinsert(item_type2keycompound, "second", 0+sizeof(int), item_type2second);
10308  hid_t item_type1val;
10309  item_type1val=H5T_NATIVE_DOUBLE;
10310  hid_t item_type1compound;
10311  item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double));
10312  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
10313  H5Tinsert(item_type1compound, "val", 0+((sizeof(int)+CYCLUS_SHA1_SIZE)), item_type1val);
10314  item_type0=sha1_type_;
10315  if(vldts_.count(VL_MAP_PAIR_INT_STRING_DOUBLE)==0){
10316  vldts_[VL_MAP_PAIR_INT_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
10317  opened_types_.insert(vldts_[VL_MAP_PAIR_INT_STRING_DOUBLE]);
10318 
10319  }
10320  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10321  field_types[i]=sha1_type_;
10322 
10323  }else if(shape[0]>=1&&shape[3]<1){
10324  dbtypes[i]=MAP_PAIR_INT_VL_STRING_DOUBLE;
10325  hid_t item_type0;
10326  hsize_t shape01=shape[0];
10327  hid_t item_type1key;
10328  hid_t item_type2first;
10329  item_type2first=H5T_NATIVE_INT;
10330  hid_t item_type2second;
10331  item_type2second=sha1_type_;
10332  hid_t item_type2keycompound;
10333  item_type2keycompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+CYCLUS_SHA1_SIZE);
10334  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
10335  H5Tinsert(item_type2keycompound, "second", 0+sizeof(int), item_type2second);
10336  hid_t item_type1val;
10337  item_type1val=H5T_NATIVE_DOUBLE;
10338  hid_t item_type1compound;
10339  item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double));
10340  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
10341  H5Tinsert(item_type1compound, "val", 0+((sizeof(int)+CYCLUS_SHA1_SIZE)), item_type1val);
10342  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10343  dst_sizes[i]=((((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double))*shape[0]);
10344  field_types[i]=item_type0;
10345  opened_types_.insert(item_type2keycompound);
10346  opened_types_.insert(item_type1compound);
10347  opened_types_.insert(field_types[i]);
10348 
10349  }else{
10350  dbtypes[i]=MAP_PAIR_INT_STRING_DOUBLE;
10351  hid_t item_type0;
10352  hsize_t shape01=shape[0];
10353  hid_t item_type1key;
10354  hid_t item_type2first;
10355  item_type2first=H5T_NATIVE_INT;
10356  hid_t item_type2second;
10357  item_type2second=CreateFLStrType(shape[3]);
10358  hid_t item_type2keycompound;
10359  item_type2keycompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+shape[3]);
10360  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
10361  H5Tinsert(item_type2keycompound, "second", 0+sizeof(int), item_type2second);
10362  hid_t item_type1val;
10363  item_type1val=H5T_NATIVE_DOUBLE;
10364  hid_t item_type1compound;
10365  item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(int)+shape[3]))+sizeof(double));
10366  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
10367  H5Tinsert(item_type1compound, "val", 0+((sizeof(int)+shape[3])), item_type1val);
10368  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10369  dst_sizes[i]=((((sizeof(int)+shape[3]))+sizeof(double))*shape[0]);
10370  field_types[i]=item_type0;
10371  opened_types_.insert(item_type2keycompound);
10372  opened_types_.insert(item_type1compound);
10373  opened_types_.insert(field_types[i]);
10374 
10375  }
10376 
10377  }else if(valtype==typeid(std::map<std::string, std::vector<double>>)){
10378  shape=shapes[i];
10379  if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1){
10381  hid_t item_type0;
10382  hid_t item_type1key;
10383  item_type1key=sha1_type_;
10384  hid_t item_type1val;
10385  hid_t item_type2elem;
10386  item_type2elem=H5T_NATIVE_DOUBLE;
10387  item_type1val=sha1_type_;
10388  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10389  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10390  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10391 
10392  }
10393  hid_t item_type1compound;
10394  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10395  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10396  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10397  item_type0=sha1_type_;
10398  if(vldts_.count(VL_MAP_VL_STRING_VL_VECTOR_DOUBLE)==0){
10399  vldts_[VL_MAP_VL_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
10400  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_VECTOR_DOUBLE]);
10401 
10402  }
10403  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10404  field_types[i]=sha1_type_;
10405 
10406  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1){
10407  dbtypes[i]=MAP_STRING_VL_VECTOR_DOUBLE;
10408  hid_t item_type0;
10409  hsize_t shape01=shape[0];
10410  hid_t item_type1key;
10411  item_type1key=CreateFLStrType(shape[1]);
10412  hid_t item_type1val;
10413  hid_t item_type2elem;
10414  item_type2elem=H5T_NATIVE_DOUBLE;
10415  item_type1val=sha1_type_;
10416  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10417  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10418  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10419 
10420  }
10421  hid_t item_type1compound;
10422  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
10423  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10424  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10425  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10426  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
10427  field_types[i]=item_type0;
10428  opened_types_.insert(item_type1val);
10429  opened_types_.insert(item_type1compound);
10430  opened_types_.insert(field_types[i]);
10431 
10432  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1){
10433  dbtypes[i]=VL_MAP_STRING_VECTOR_DOUBLE;
10434  hid_t item_type0;
10435  hid_t item_type1key;
10436  item_type1key=sha1_type_;
10437  hid_t item_type1val;
10438  hsize_t shape02=shape[2];
10439  hid_t item_type2elem;
10440  item_type2elem=H5T_NATIVE_DOUBLE;
10441  item_type1val=sha1_type_;
10442  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10443  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10444  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10445 
10446  }
10447  hid_t item_type1compound;
10448  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10449  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10450  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10451  item_type0=sha1_type_;
10452  if(vldts_.count(VL_MAP_STRING_VECTOR_DOUBLE)==0){
10453  vldts_[VL_MAP_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
10454  opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_DOUBLE]);
10455 
10456  }
10457  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10458  field_types[i]=sha1_type_;
10459 
10460  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1){
10461  dbtypes[i]=MAP_VL_STRING_VECTOR_DOUBLE;
10462  hid_t item_type0;
10463  hsize_t shape01=shape[0];
10464  hid_t item_type1key;
10465  item_type1key=sha1_type_;
10466  hid_t item_type1val;
10467  hsize_t shape02=shape[2];
10468  hid_t item_type2elem;
10469  item_type2elem=H5T_NATIVE_DOUBLE;
10470  item_type1val=H5Tarray_create2(item_type2elem, 1, &shape02);
10471  hid_t item_type1compound;
10472  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2]));
10473  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10474  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10475  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10476  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2]))*shape[0]);
10477  field_types[i]=item_type0;
10478  opened_types_.insert(item_type1val);
10479  opened_types_.insert(item_type1compound);
10480  opened_types_.insert(field_types[i]);
10481 
10482  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1){
10483  dbtypes[i]=MAP_VL_STRING_VL_VECTOR_DOUBLE;
10484  hid_t item_type0;
10485  hsize_t shape01=shape[0];
10486  hid_t item_type1key;
10487  item_type1key=sha1_type_;
10488  hid_t item_type1val;
10489  hid_t item_type2elem;
10490  item_type2elem=H5T_NATIVE_DOUBLE;
10491  item_type1val=sha1_type_;
10492  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10493  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10494  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10495 
10496  }
10497  hid_t item_type1compound;
10498  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10499  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10500  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10501  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10502  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
10503  field_types[i]=item_type0;
10504  opened_types_.insert(item_type1val);
10505  opened_types_.insert(item_type1compound);
10506  opened_types_.insert(field_types[i]);
10507 
10508  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1){
10509  dbtypes[i]=VL_MAP_STRING_VL_VECTOR_DOUBLE;
10510  hid_t item_type0;
10511  hid_t item_type1key;
10512  item_type1key=sha1_type_;
10513  hid_t item_type1val;
10514  hid_t item_type2elem;
10515  item_type2elem=H5T_NATIVE_DOUBLE;
10516  item_type1val=sha1_type_;
10517  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10518  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10519  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10520 
10521  }
10522  hid_t item_type1compound;
10523  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10524  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10525  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10526  item_type0=sha1_type_;
10527  if(vldts_.count(VL_MAP_STRING_VL_VECTOR_DOUBLE)==0){
10528  vldts_[VL_MAP_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
10529  opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_DOUBLE]);
10530 
10531  }
10532  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10533  field_types[i]=sha1_type_;
10534 
10535  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1){
10536  dbtypes[i]=VL_MAP_VL_STRING_VECTOR_DOUBLE;
10537  hid_t item_type0;
10538  hid_t item_type1key;
10539  item_type1key=sha1_type_;
10540  hid_t item_type1val;
10541  hsize_t shape02=shape[2];
10542  hid_t item_type2elem;
10543  item_type2elem=H5T_NATIVE_DOUBLE;
10544  item_type1val=sha1_type_;
10545  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
10546  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
10547  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
10548 
10549  }
10550  hid_t item_type1compound;
10551  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10552  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10553  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10554  item_type0=sha1_type_;
10555  if(vldts_.count(VL_MAP_VL_STRING_VECTOR_DOUBLE)==0){
10556  vldts_[VL_MAP_VL_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
10557  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_DOUBLE]);
10558 
10559  }
10560  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10561  field_types[i]=sha1_type_;
10562 
10563  }else{
10564  dbtypes[i]=MAP_STRING_VECTOR_DOUBLE;
10565  hid_t item_type0;
10566  hsize_t shape01=shape[0];
10567  hid_t item_type1key;
10568  item_type1key=CreateFLStrType(shape[1]);
10569  hid_t item_type1val;
10570  hsize_t shape02=shape[2];
10571  hid_t item_type2elem;
10572  item_type2elem=H5T_NATIVE_DOUBLE;
10573  item_type1val=H5Tarray_create2(item_type2elem, 1, &shape02);
10574  hid_t item_type1compound;
10575  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(double))*shape[2]));
10576  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10577  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10578  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10579  dst_sizes[i]=((shape[1]+((sizeof(double))*shape[2]))*shape[0]);
10580  field_types[i]=item_type0;
10581  opened_types_.insert(item_type1val);
10582  opened_types_.insert(item_type1compound);
10583  opened_types_.insert(field_types[i]);
10584 
10585  }
10586 
10587  }else if(valtype==typeid(std::map<std::string, std::map<int, double>>)){
10588  shape=shapes[i];
10589  if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1){
10591  hid_t item_type0;
10592  hid_t item_type1key;
10593  item_type1key=sha1_type_;
10594  hid_t item_type1val;
10595  hid_t item_type2key;
10596  item_type2key=H5T_NATIVE_INT;
10597  hid_t item_type2val;
10598  item_type2val=H5T_NATIVE_DOUBLE;
10599  hid_t item_type2valcompound;
10600  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10601  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10602  H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10603  item_type1val=sha1_type_;
10604  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10605  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10606  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10607 
10608  }
10609  hid_t item_type1compound;
10610  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10611  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10612  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10613  item_type0=sha1_type_;
10614  if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE)==0){
10615  vldts_[VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10616  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE]);
10617 
10618  }
10619  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10620  field_types[i]=sha1_type_;
10621 
10622  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1){
10623  dbtypes[i]=MAP_STRING_VL_MAP_INT_DOUBLE;
10624  hid_t item_type0;
10625  hsize_t shape01=shape[0];
10626  hid_t item_type1key;
10627  item_type1key=CreateFLStrType(shape[1]);
10628  hid_t item_type1val;
10629  hid_t item_type2key;
10630  item_type2key=H5T_NATIVE_INT;
10631  hid_t item_type2val;
10632  item_type2val=H5T_NATIVE_DOUBLE;
10633  hid_t item_type2valcompound;
10634  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10635  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10636  H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10637  item_type1val=sha1_type_;
10638  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10639  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10640  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10641 
10642  }
10643  hid_t item_type1compound;
10644  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
10645  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10646  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10647  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10648  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
10649  field_types[i]=item_type0;
10650  opened_types_.insert(item_type2valcompound);
10651  opened_types_.insert(item_type1val);
10652  opened_types_.insert(item_type1compound);
10653  opened_types_.insert(field_types[i]);
10654 
10655  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1){
10656  dbtypes[i]=VL_MAP_STRING_MAP_INT_DOUBLE;
10657  hid_t item_type0;
10658  hid_t item_type1key;
10659  item_type1key=sha1_type_;
10660  hid_t item_type1val;
10661  hsize_t shape02=shape[2];
10662  hid_t item_type2key;
10663  item_type2key=H5T_NATIVE_INT;
10664  hid_t item_type2val;
10665  item_type2val=H5T_NATIVE_DOUBLE;
10666  hid_t item_type2valcompound;
10667  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10668  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10669  H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10670  item_type1val=sha1_type_;
10671  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10672  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10673  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10674 
10675  }
10676  hid_t item_type1compound;
10677  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10678  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10679  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10680  item_type0=sha1_type_;
10681  if(vldts_.count(VL_MAP_STRING_MAP_INT_DOUBLE)==0){
10682  vldts_[VL_MAP_STRING_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10683  opened_types_.insert(vldts_[VL_MAP_STRING_MAP_INT_DOUBLE]);
10684 
10685  }
10686  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10687  field_types[i]=sha1_type_;
10688 
10689  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1){
10690  dbtypes[i]=MAP_VL_STRING_MAP_INT_DOUBLE;
10691  hid_t item_type0;
10692  hsize_t shape01=shape[0];
10693  hid_t item_type1key;
10694  item_type1key=sha1_type_;
10695  hid_t item_type1val;
10696  hsize_t shape02=shape[2];
10697  hid_t item_type2key;
10698  item_type2key=H5T_NATIVE_INT;
10699  hid_t item_type2val;
10700  item_type2val=H5T_NATIVE_DOUBLE;
10701  hid_t item_type2valcompound;
10702  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10703  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10704  H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10705  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
10706  hid_t item_type1compound;
10707  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(int)+sizeof(double))*shape[2]));
10708  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10709  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10710  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10711  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(int)+sizeof(double))*shape[2]))*shape[0]);
10712  field_types[i]=item_type0;
10713  opened_types_.insert(item_type2valcompound);
10714  opened_types_.insert(item_type1val);
10715  opened_types_.insert(item_type1compound);
10716  opened_types_.insert(field_types[i]);
10717 
10718  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1){
10720  hid_t item_type0;
10721  hsize_t shape01=shape[0];
10722  hid_t item_type1key;
10723  item_type1key=sha1_type_;
10724  hid_t item_type1val;
10725  hid_t item_type2key;
10726  item_type2key=H5T_NATIVE_INT;
10727  hid_t item_type2val;
10728  item_type2val=H5T_NATIVE_DOUBLE;
10729  hid_t item_type2valcompound;
10730  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10731  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10732  H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10733  item_type1val=sha1_type_;
10734  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10735  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10736  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10737 
10738  }
10739  hid_t item_type1compound;
10740  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10741  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10742  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10743  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10744  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
10745  field_types[i]=item_type0;
10746  opened_types_.insert(item_type2valcompound);
10747  opened_types_.insert(item_type1val);
10748  opened_types_.insert(item_type1compound);
10749  opened_types_.insert(field_types[i]);
10750 
10751  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1){
10753  hid_t item_type0;
10754  hid_t item_type1key;
10755  item_type1key=sha1_type_;
10756  hid_t item_type1val;
10757  hid_t item_type2key;
10758  item_type2key=H5T_NATIVE_INT;
10759  hid_t item_type2val;
10760  item_type2val=H5T_NATIVE_DOUBLE;
10761  hid_t item_type2valcompound;
10762  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10763  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10764  H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10765  item_type1val=sha1_type_;
10766  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10767  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10768  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10769 
10770  }
10771  hid_t item_type1compound;
10772  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10773  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10774  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10775  item_type0=sha1_type_;
10776  if(vldts_.count(VL_MAP_STRING_VL_MAP_INT_DOUBLE)==0){
10777  vldts_[VL_MAP_STRING_VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10778  opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_INT_DOUBLE]);
10779 
10780  }
10781  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10782  field_types[i]=sha1_type_;
10783 
10784  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1){
10786  hid_t item_type0;
10787  hid_t item_type1key;
10788  item_type1key=sha1_type_;
10789  hid_t item_type1val;
10790  hsize_t shape02=shape[2];
10791  hid_t item_type2key;
10792  item_type2key=H5T_NATIVE_INT;
10793  hid_t item_type2val;
10794  item_type2val=H5T_NATIVE_DOUBLE;
10795  hid_t item_type2valcompound;
10796  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10797  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10798  H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10799  item_type1val=sha1_type_;
10800  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10801  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2valcompound);
10802  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10803 
10804  }
10805  hid_t item_type1compound;
10806  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
10807  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10808  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
10809  item_type0=sha1_type_;
10810  if(vldts_.count(VL_MAP_VL_STRING_MAP_INT_DOUBLE)==0){
10811  vldts_[VL_MAP_VL_STRING_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10812  opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_INT_DOUBLE]);
10813 
10814  }
10815  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10816  field_types[i]=sha1_type_;
10817 
10818  }else{
10819  dbtypes[i]=MAP_STRING_MAP_INT_DOUBLE;
10820  hid_t item_type0;
10821  hsize_t shape01=shape[0];
10822  hid_t item_type1key;
10823  item_type1key=CreateFLStrType(shape[1]);
10824  hid_t item_type1val;
10825  hsize_t shape02=shape[2];
10826  hid_t item_type2key;
10827  item_type2key=H5T_NATIVE_INT;
10828  hid_t item_type2val;
10829  item_type2val=H5T_NATIVE_DOUBLE;
10830  hid_t item_type2valcompound;
10831  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10832  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
10833  H5Tinsert(item_type2valcompound, "val", 0+sizeof(int), item_type2val);
10834  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
10835  hid_t item_type1compound;
10836  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(int)+sizeof(double))*shape[2]));
10837  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10838  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
10839  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10840  dst_sizes[i]=((shape[1]+((sizeof(int)+sizeof(double))*shape[2]))*shape[0]);
10841  field_types[i]=item_type0;
10842  opened_types_.insert(item_type2valcompound);
10843  opened_types_.insert(item_type1val);
10844  opened_types_.insert(item_type1compound);
10845  opened_types_.insert(field_types[i]);
10846 
10847  }
10848 
10849  }else if(valtype==typeid(std::map<std::string, std::pair<double, std::map<int, double>>>)){
10850  shape=shapes[i];
10851  if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[4]<1){
10853  hid_t item_type0;
10854  hid_t item_type1key;
10855  item_type1key=sha1_type_;
10856  hid_t item_type1val;
10857  hid_t item_type2first;
10858  item_type2first=H5T_NATIVE_DOUBLE;
10859  hid_t item_type2second;
10860  hid_t item_type3key;
10861  item_type3key=H5T_NATIVE_INT;
10862  hid_t item_type3val;
10863  item_type3val=H5T_NATIVE_DOUBLE;
10864  hid_t item_type3secondcompound;
10865  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10866  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
10867  H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
10868  item_type2second=sha1_type_;
10869  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10870  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
10871  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10872 
10873  }
10874  hid_t item_type2valcompound;
10875  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
10876  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
10877  H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
10878  hid_t item_type1compound;
10879  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
10880  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10881  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
10882  item_type0=sha1_type_;
10884  vldts_[VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10885  opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE]);
10886 
10887  }
10888  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10889  field_types[i]=sha1_type_;
10890 
10891  }else if(shape[0]<1&&shape[1]>=1&&shape[4]>=1){
10893  hid_t item_type0;
10894  hid_t item_type1key;
10895  item_type1key=sha1_type_;
10896  hid_t item_type1val;
10897  hid_t item_type2first;
10898  item_type2first=H5T_NATIVE_DOUBLE;
10899  hid_t item_type2second;
10900  hsize_t shape03=shape[4];
10901  hid_t item_type3key;
10902  item_type3key=H5T_NATIVE_INT;
10903  hid_t item_type3val;
10904  item_type3val=H5T_NATIVE_DOUBLE;
10905  hid_t item_type3secondcompound;
10906  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10907  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
10908  H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
10909  item_type2second=sha1_type_;
10910  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10911  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
10912  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10913 
10914  }
10915  hid_t item_type2valcompound;
10916  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
10917  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
10918  H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
10919  hid_t item_type1compound;
10920  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
10921  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10922  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
10923  item_type0=sha1_type_;
10924  if(vldts_.count(VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE)==0){
10925  vldts_[VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
10926  opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE]);
10927 
10928  }
10929  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
10930  field_types[i]=sha1_type_;
10931 
10932  }else if(shape[0]>=1&&shape[1]<1&&shape[4]>=1){
10934  hid_t item_type0;
10935  hsize_t shape01=shape[0];
10936  hid_t item_type1key;
10937  item_type1key=sha1_type_;
10938  hid_t item_type1val;
10939  hid_t item_type2first;
10940  item_type2first=H5T_NATIVE_DOUBLE;
10941  hid_t item_type2second;
10942  hsize_t shape03=shape[4];
10943  hid_t item_type3key;
10944  item_type3key=H5T_NATIVE_INT;
10945  hid_t item_type3val;
10946  item_type3val=H5T_NATIVE_DOUBLE;
10947  hid_t item_type3secondcompound;
10948  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10949  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
10950  H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
10951  item_type2second=H5Tarray_create2(item_type3secondcompound, 1, &shape03);
10952  hid_t item_type2valcompound;
10953  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]));
10954  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
10955  H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
10956  hid_t item_type1compound;
10957  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))));
10958  H5Tinsert(item_type1compound, "key", 0, item_type1key);
10959  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
10960  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
10961  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))))*shape[0]);
10962  field_types[i]=item_type0;
10963  opened_types_.insert(item_type3secondcompound);
10964  opened_types_.insert(item_type2second);
10965  opened_types_.insert(item_type2valcompound);
10966  opened_types_.insert(item_type1compound);
10967  opened_types_.insert(field_types[i]);
10968 
10969  }else if(shape[0]>=1&&shape[1]>=1&&shape[4]<1){
10971  hid_t item_type0;
10972  hsize_t shape01=shape[0];
10973  hid_t item_type1key;
10974  item_type1key=CreateFLStrType(shape[1]);
10975  hid_t item_type1val;
10976  hid_t item_type2first;
10977  item_type2first=H5T_NATIVE_DOUBLE;
10978  hid_t item_type2second;
10979  hid_t item_type3key;
10980  item_type3key=H5T_NATIVE_INT;
10981  hid_t item_type3val;
10982  item_type3val=H5T_NATIVE_DOUBLE;
10983  hid_t item_type3secondcompound;
10984  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
10985  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
10986  H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
10987  item_type2second=sha1_type_;
10988  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
10989  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
10990  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
10991 
10992  }
10993  hid_t item_type2valcompound;
10994  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
10995  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
10996  H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
10997  hid_t item_type1compound;
10998  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
10999  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11000  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
11001  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11002  dst_sizes[i]=((shape[1]+((sizeof(double)+(CYCLUS_SHA1_SIZE))))*shape[0]);
11003  field_types[i]=item_type0;
11004  opened_types_.insert(item_type3secondcompound);
11005  opened_types_.insert(item_type2second);
11006  opened_types_.insert(item_type2valcompound);
11007  opened_types_.insert(item_type1compound);
11008  opened_types_.insert(field_types[i]);
11009 
11010  }else if(shape[0]<1&&shape[1]<1&&shape[4]>=1){
11012  hid_t item_type0;
11013  hid_t item_type1key;
11014  item_type1key=sha1_type_;
11015  hid_t item_type1val;
11016  hid_t item_type2first;
11017  item_type2first=H5T_NATIVE_DOUBLE;
11018  hid_t item_type2second;
11019  hsize_t shape03=shape[4];
11020  hid_t item_type3key;
11021  item_type3key=H5T_NATIVE_INT;
11022  hid_t item_type3val;
11023  item_type3val=H5T_NATIVE_DOUBLE;
11024  hid_t item_type3secondcompound;
11025  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
11026  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
11027  H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
11028  item_type2second=sha1_type_;
11029  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
11030  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
11031  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
11032 
11033  }
11034  hid_t item_type2valcompound;
11035  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
11036  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
11037  H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
11038  hid_t item_type1compound;
11039  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
11040  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11041  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
11042  item_type0=sha1_type_;
11043  if(vldts_.count(VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE)==0){
11044  vldts_[VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
11045  opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE]);
11046 
11047  }
11048  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11049  field_types[i]=sha1_type_;
11050 
11051  }else if(shape[0]<1&&shape[1]>=1&&shape[4]<1){
11053  hid_t item_type0;
11054  hid_t item_type1key;
11055  item_type1key=sha1_type_;
11056  hid_t item_type1val;
11057  hid_t item_type2first;
11058  item_type2first=H5T_NATIVE_DOUBLE;
11059  hid_t item_type2second;
11060  hid_t item_type3key;
11061  item_type3key=H5T_NATIVE_INT;
11062  hid_t item_type3val;
11063  item_type3val=H5T_NATIVE_DOUBLE;
11064  hid_t item_type3secondcompound;
11065  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
11066  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
11067  H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
11068  item_type2second=sha1_type_;
11069  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
11070  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
11071  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
11072 
11073  }
11074  hid_t item_type2valcompound;
11075  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
11076  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
11077  H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
11078  hid_t item_type1compound;
11079  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
11080  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11081  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
11082  item_type0=sha1_type_;
11083  if(vldts_.count(VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE)==0){
11084  vldts_[VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type1compound);
11085  opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE]);
11086 
11087  }
11088  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11089  field_types[i]=sha1_type_;
11090 
11091  }else if(shape[0]>=1&&shape[1]<1&&shape[4]<1){
11093  hid_t item_type0;
11094  hsize_t shape01=shape[0];
11095  hid_t item_type1key;
11096  item_type1key=sha1_type_;
11097  hid_t item_type1val;
11098  hid_t item_type2first;
11099  item_type2first=H5T_NATIVE_DOUBLE;
11100  hid_t item_type2second;
11101  hid_t item_type3key;
11102  item_type3key=H5T_NATIVE_INT;
11103  hid_t item_type3val;
11104  item_type3val=H5T_NATIVE_DOUBLE;
11105  hid_t item_type3secondcompound;
11106  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
11107  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
11108  H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
11109  item_type2second=sha1_type_;
11110  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
11111  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
11112  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
11113 
11114  }
11115  hid_t item_type2valcompound;
11116  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
11117  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
11118  H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
11119  hid_t item_type1compound;
11120  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))));
11121  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11122  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
11123  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11124  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))))*shape[0]);
11125  field_types[i]=item_type0;
11126  opened_types_.insert(item_type3secondcompound);
11127  opened_types_.insert(item_type2second);
11128  opened_types_.insert(item_type2valcompound);
11129  opened_types_.insert(item_type1compound);
11130  opened_types_.insert(field_types[i]);
11131 
11132  }else{
11134  hid_t item_type0;
11135  hsize_t shape01=shape[0];
11136  hid_t item_type1key;
11137  item_type1key=CreateFLStrType(shape[1]);
11138  hid_t item_type1val;
11139  hid_t item_type2first;
11140  item_type2first=H5T_NATIVE_DOUBLE;
11141  hid_t item_type2second;
11142  hsize_t shape03=shape[4];
11143  hid_t item_type3key;
11144  item_type3key=H5T_NATIVE_INT;
11145  hid_t item_type3val;
11146  item_type3val=H5T_NATIVE_DOUBLE;
11147  hid_t item_type3secondcompound;
11148  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
11149  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
11150  H5Tinsert(item_type3secondcompound, "val", 0+sizeof(int), item_type3val);
11151  item_type2second=H5Tarray_create2(item_type3secondcompound, 1, &shape03);
11152  hid_t item_type2valcompound;
11153  item_type2valcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]));
11154  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
11155  H5Tinsert(item_type2valcompound, "second", 0+sizeof(double), item_type2second);
11156  hid_t item_type1compound;
11157  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))));
11158  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11159  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
11160  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11161  dst_sizes[i]=((shape[1]+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))))*shape[0]);
11162  field_types[i]=item_type0;
11163  opened_types_.insert(item_type3secondcompound);
11164  opened_types_.insert(item_type2second);
11165  opened_types_.insert(item_type2valcompound);
11166  opened_types_.insert(item_type1compound);
11167  opened_types_.insert(field_types[i]);
11168 
11169  }
11170 
11171  }else if(valtype==typeid(std::map<int, std::map<std::string, double>>)){
11172  shape=shapes[i];
11173  if(shape.empty()||shape[0]<1&&shape[2]<1&&shape[3]<1){
11175  hid_t item_type0;
11176  hid_t item_type1key;
11177  item_type1key=H5T_NATIVE_INT;
11178  hid_t item_type1val;
11179  hid_t item_type2key;
11180  item_type2key=sha1_type_;
11181  hid_t item_type2val;
11182  item_type2val=H5T_NATIVE_DOUBLE;
11183  hid_t item_type2valcompound;
11184  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11185  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11186  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11187  item_type1val=sha1_type_;
11188  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11189  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11190  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11191 
11192  }
11193  hid_t item_type1compound;
11194  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11195  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11196  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11197  item_type0=sha1_type_;
11198  if(vldts_.count(VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE)==0){
11199  vldts_[VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
11200  opened_types_.insert(vldts_[VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE]);
11201 
11202  }
11203  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11204  field_types[i]=sha1_type_;
11205 
11206  }else if(shape[0]>=1&&shape[2]>=1&&shape[3]<1){
11207  dbtypes[i]=MAP_INT_MAP_VL_STRING_DOUBLE;
11208  hid_t item_type0;
11209  hsize_t shape01=shape[0];
11210  hid_t item_type1key;
11211  item_type1key=H5T_NATIVE_INT;
11212  hid_t item_type1val;
11213  hsize_t shape02=shape[2];
11214  hid_t item_type2key;
11215  item_type2key=sha1_type_;
11216  hid_t item_type2val;
11217  item_type2val=H5T_NATIVE_DOUBLE;
11218  hid_t item_type2valcompound;
11219  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11220  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11221  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11222  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
11223  hid_t item_type1compound;
11224  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]));
11225  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11226  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11227  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11228  dst_sizes[i]=((sizeof(int)+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
11229  field_types[i]=item_type0;
11230  opened_types_.insert(item_type2valcompound);
11231  opened_types_.insert(item_type1val);
11232  opened_types_.insert(item_type1compound);
11233  opened_types_.insert(field_types[i]);
11234 
11235  }else if(shape[0]<1&&shape[2]>=1&&shape[3]>=1){
11236  dbtypes[i]=VL_MAP_INT_MAP_STRING_DOUBLE;
11237  hid_t item_type0;
11238  hid_t item_type1key;
11239  item_type1key=H5T_NATIVE_INT;
11240  hid_t item_type1val;
11241  hsize_t shape02=shape[2];
11242  hid_t item_type2key;
11243  item_type2key=sha1_type_;
11244  hid_t item_type2val;
11245  item_type2val=H5T_NATIVE_DOUBLE;
11246  hid_t item_type2valcompound;
11247  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11248  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11249  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11250  item_type1val=sha1_type_;
11251  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11252  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11253  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11254 
11255  }
11256  hid_t item_type1compound;
11257  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11258  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11259  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11260  item_type0=sha1_type_;
11261  if(vldts_.count(VL_MAP_INT_MAP_STRING_DOUBLE)==0){
11262  vldts_[VL_MAP_INT_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
11263  opened_types_.insert(vldts_[VL_MAP_INT_MAP_STRING_DOUBLE]);
11264 
11265  }
11266  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11267  field_types[i]=sha1_type_;
11268 
11269  }else if(shape[0]<1&&shape[2]>=1&&shape[3]<1){
11271  hid_t item_type0;
11272  hid_t item_type1key;
11273  item_type1key=H5T_NATIVE_INT;
11274  hid_t item_type1val;
11275  hsize_t shape02=shape[2];
11276  hid_t item_type2key;
11277  item_type2key=sha1_type_;
11278  hid_t item_type2val;
11279  item_type2val=H5T_NATIVE_DOUBLE;
11280  hid_t item_type2valcompound;
11281  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11282  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11283  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11284  item_type1val=sha1_type_;
11285  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11286  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11287  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11288 
11289  }
11290  hid_t item_type1compound;
11291  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11292  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11293  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11294  item_type0=sha1_type_;
11295  if(vldts_.count(VL_MAP_INT_MAP_VL_STRING_DOUBLE)==0){
11296  vldts_[VL_MAP_INT_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
11297  opened_types_.insert(vldts_[VL_MAP_INT_MAP_VL_STRING_DOUBLE]);
11298 
11299  }
11300  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11301  field_types[i]=sha1_type_;
11302 
11303  }else if(shape[0]>=1&&shape[2]<1&&shape[3]>=1){
11304  dbtypes[i]=MAP_INT_VL_MAP_STRING_DOUBLE;
11305  hid_t item_type0;
11306  hsize_t shape01=shape[0];
11307  hid_t item_type1key;
11308  item_type1key=H5T_NATIVE_INT;
11309  hid_t item_type1val;
11310  hid_t item_type2key;
11311  item_type2key=sha1_type_;
11312  hid_t item_type2val;
11313  item_type2val=H5T_NATIVE_DOUBLE;
11314  hid_t item_type2valcompound;
11315  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11316  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11317  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11318  item_type1val=sha1_type_;
11319  if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
11320  vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11321  opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
11322 
11323  }
11324  hid_t item_type1compound;
11325  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11326  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11327  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11328  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11329  dst_sizes[i]=((sizeof(int)+(CYCLUS_SHA1_SIZE))*shape[0]);
11330  field_types[i]=item_type0;
11331  opened_types_.insert(item_type2valcompound);
11332  opened_types_.insert(item_type1val);
11333  opened_types_.insert(item_type1compound);
11334  opened_types_.insert(field_types[i]);
11335 
11336  }else if(shape[0]>=1&&shape[2]<1&&shape[3]<1){
11338  hid_t item_type0;
11339  hsize_t shape01=shape[0];
11340  hid_t item_type1key;
11341  item_type1key=H5T_NATIVE_INT;
11342  hid_t item_type1val;
11343  hid_t item_type2key;
11344  item_type2key=sha1_type_;
11345  hid_t item_type2val;
11346  item_type2val=H5T_NATIVE_DOUBLE;
11347  hid_t item_type2valcompound;
11348  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11349  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11350  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11351  item_type1val=sha1_type_;
11352  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11353  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11354  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11355 
11356  }
11357  hid_t item_type1compound;
11358  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11359  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11360  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11361  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11362  dst_sizes[i]=((sizeof(int)+(CYCLUS_SHA1_SIZE))*shape[0]);
11363  field_types[i]=item_type0;
11364  opened_types_.insert(item_type2valcompound);
11365  opened_types_.insert(item_type1val);
11366  opened_types_.insert(item_type1compound);
11367  opened_types_.insert(field_types[i]);
11368 
11369  }else if(shape[0]<1&&shape[2]<1&&shape[3]>=1){
11371  hid_t item_type0;
11372  hid_t item_type1key;
11373  item_type1key=H5T_NATIVE_INT;
11374  hid_t item_type1val;
11375  hid_t item_type2key;
11376  item_type2key=sha1_type_;
11377  hid_t item_type2val;
11378  item_type2val=H5T_NATIVE_DOUBLE;
11379  hid_t item_type2valcompound;
11380  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
11381  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11382  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
11383  item_type1val=sha1_type_;
11384  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
11385  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2valcompound);
11386  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
11387 
11388  }
11389  hid_t item_type1compound;
11390  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+(CYCLUS_SHA1_SIZE));
11391  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11392  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11393  item_type0=sha1_type_;
11394  if(vldts_.count(VL_MAP_INT_VL_MAP_STRING_DOUBLE)==0){
11395  vldts_[VL_MAP_INT_VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type1compound);
11396  opened_types_.insert(vldts_[VL_MAP_INT_VL_MAP_STRING_DOUBLE]);
11397 
11398  }
11399  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11400  field_types[i]=sha1_type_;
11401 
11402  }else{
11403  dbtypes[i]=MAP_INT_MAP_STRING_DOUBLE;
11404  hid_t item_type0;
11405  hsize_t shape01=shape[0];
11406  hid_t item_type1key;
11407  item_type1key=H5T_NATIVE_INT;
11408  hid_t item_type1val;
11409  hsize_t shape02=shape[2];
11410  hid_t item_type2key;
11411  item_type2key=CreateFLStrType(shape[3]);
11412  hid_t item_type2val;
11413  item_type2val=H5T_NATIVE_DOUBLE;
11414  hid_t item_type2valcompound;
11415  item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(double));
11416  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
11417  H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
11418  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
11419  hid_t item_type1compound;
11420  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[3]+sizeof(double))*shape[2]));
11421  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11422  H5Tinsert(item_type1compound, "val", 0+sizeof(int), item_type1val);
11423  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11424  dst_sizes[i]=((sizeof(int)+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
11425  field_types[i]=item_type0;
11426  opened_types_.insert(item_type2valcompound);
11427  opened_types_.insert(item_type1val);
11428  opened_types_.insert(item_type1compound);
11429  opened_types_.insert(field_types[i]);
11430 
11431  }
11432 
11433  }else if(valtype==typeid(std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>)){
11434  shape=shapes[i];
11435  if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[6]<1&&shape[7]<1){
11437  hid_t item_type0;
11438  hid_t item_type1key;
11439  item_type1key=sha1_type_;
11440  hid_t item_type1val;
11441  hid_t item_type2elem;
11442  hid_t item_type3first;
11443  item_type3first=H5T_NATIVE_INT;
11444  hid_t item_type3second;
11445  hid_t item_type4first;
11446  item_type4first=sha1_type_;
11447  hid_t item_type4second;
11448  item_type4second=sha1_type_;
11449  hid_t item_type4secondcompound;
11450  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11451  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11452  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11453  hid_t item_type3elemcompound;
11454  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11455  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11456  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11457  item_type1val=sha1_type_;
11458  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
11459  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
11460  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
11461 
11462  }
11463  hid_t item_type1compound;
11464  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
11465  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11466  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11467  item_type0=sha1_type_;
11469  vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
11471 
11472  }
11473  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
11474  field_types[i]=sha1_type_;
11475 
11476  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[6]>=1&&shape[7]<1){
11478  hid_t item_type0;
11479  hsize_t shape01=shape[0];
11480  hid_t item_type1key;
11481  item_type1key=CreateFLStrType(shape[1]);
11482  hid_t item_type1val;
11483  hsize_t shape02=shape[2];
11484  hid_t item_type2elem;
11485  hid_t item_type3first;
11486  item_type3first=H5T_NATIVE_INT;
11487  hid_t item_type3second;
11488  hid_t item_type4first;
11489  item_type4first=CreateFLStrType(shape[6]);
11490  hid_t item_type4second;
11491  item_type4second=sha1_type_;
11492  hid_t item_type4secondcompound;
11493  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+CYCLUS_SHA1_SIZE);
11494  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11495  H5Tinsert(item_type4secondcompound, "second", 0+shape[6], item_type4second);
11496  hid_t item_type3elemcompound;
11497  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)));
11498  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11499  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11500  item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11501  hid_t item_type1compound;
11502  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]));
11503  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11504  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11505  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11506  dst_sizes[i]=((shape[1]+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
11507  field_types[i]=item_type0;
11508  opened_types_.insert(item_type4secondcompound);
11509  opened_types_.insert(item_type3elemcompound);
11510  opened_types_.insert(item_type1val);
11511  opened_types_.insert(item_type1compound);
11512  opened_types_.insert(field_types[i]);
11513 
11514  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[6]<1&&shape[7]>=1){
11516  hid_t item_type0;
11517  hsize_t shape01=shape[0];
11518  hid_t item_type1key;
11519  item_type1key=CreateFLStrType(shape[1]);
11520  hid_t item_type1val;
11521  hsize_t shape02=shape[2];
11522  hid_t item_type2elem;
11523  hid_t item_type3first;
11524  item_type3first=H5T_NATIVE_INT;
11525  hid_t item_type3second;
11526  hid_t item_type4first;
11527  item_type4first=sha1_type_;
11528  hid_t item_type4second;
11529  item_type4second=CreateFLStrType(shape[7]);
11530  hid_t item_type4secondcompound;
11531  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[7]);
11532  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11533  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11534  hid_t item_type3elemcompound;
11535  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])));
11536  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11537  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11538  item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11539  hid_t item_type1compound;
11540  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]));
11541  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11542  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11543  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11544  dst_sizes[i]=((shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]))*shape[0]);
11545  field_types[i]=item_type0;
11546  opened_types_.insert(item_type4secondcompound);
11547  opened_types_.insert(item_type3elemcompound);
11548  opened_types_.insert(item_type1val);
11549  opened_types_.insert(item_type1compound);
11550  opened_types_.insert(field_types[i]);
11551 
11552  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[6]<1&&shape[7]<1){
11554  hid_t item_type0;
11555  hsize_t shape01=shape[0];
11556  hid_t item_type1key;
11557  item_type1key=CreateFLStrType(shape[1]);
11558  hid_t item_type1val;
11559  hsize_t shape02=shape[2];
11560  hid_t item_type2elem;
11561  hid_t item_type3first;
11562  item_type3first=H5T_NATIVE_INT;
11563  hid_t item_type3second;
11564  hid_t item_type4first;
11565  item_type4first=sha1_type_;
11566  hid_t item_type4second;
11567  item_type4second=sha1_type_;
11568  hid_t item_type4secondcompound;
11569  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11570  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11571  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11572  hid_t item_type3elemcompound;
11573  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11574  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11575  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11576  item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11577  hid_t item_type1compound;
11578  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]));
11579  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11580  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11581  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11582  dst_sizes[i]=((shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
11583  field_types[i]=item_type0;
11584  opened_types_.insert(item_type4secondcompound);
11585  opened_types_.insert(item_type3elemcompound);
11586  opened_types_.insert(item_type1val);
11587  opened_types_.insert(item_type1compound);
11588  opened_types_.insert(field_types[i]);
11589 
11590  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[6]>=1&&shape[7]>=1){
11592  hid_t item_type0;
11593  hsize_t shape01=shape[0];
11594  hid_t item_type1key;
11595  item_type1key=CreateFLStrType(shape[1]);
11596  hid_t item_type1val;
11597  hid_t item_type2elem;
11598  hid_t item_type3first;
11599  item_type3first=H5T_NATIVE_INT;
11600  hid_t item_type3second;
11601  hid_t item_type4first;
11602  item_type4first=sha1_type_;
11603  hid_t item_type4second;
11604  item_type4second=sha1_type_;
11605  hid_t item_type4secondcompound;
11606  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11607  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11608  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11609  hid_t item_type3elemcompound;
11610  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11611  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11612  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11613  item_type1val=sha1_type_;
11614  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
11615  vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type3elemcompound);
11616  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
11617 
11618  }
11619  hid_t item_type1compound;
11620  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
11621  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11622  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11623  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11624  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
11625  field_types[i]=item_type0;
11626  opened_types_.insert(item_type4secondcompound);
11627  opened_types_.insert(item_type3elemcompound);
11628  opened_types_.insert(item_type1val);
11629  opened_types_.insert(item_type1compound);
11630  opened_types_.insert(field_types[i]);
11631 
11632  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[6]>=1&&shape[7]<1){
11634  hid_t item_type0;
11635  hsize_t shape01=shape[0];
11636  hid_t item_type1key;
11637  item_type1key=CreateFLStrType(shape[1]);
11638  hid_t item_type1val;
11639  hid_t item_type2elem;
11640  hid_t item_type3first;
11641  item_type3first=H5T_NATIVE_INT;
11642  hid_t item_type3second;
11643  hid_t item_type4first;
11644  item_type4first=sha1_type_;
11645  hid_t item_type4second;
11646  item_type4second=sha1_type_;
11647  hid_t item_type4secondcompound;
11648  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11649  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11650  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11651  hid_t item_type3elemcompound;
11652  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11653  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11654  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11655  item_type1val=sha1_type_;
11656  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
11657  vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
11658  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
11659 
11660  }
11661  hid_t item_type1compound;
11662  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
11663  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11664  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11665  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11666  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
11667  field_types[i]=item_type0;
11668  opened_types_.insert(item_type4secondcompound);
11669  opened_types_.insert(item_type3elemcompound);
11670  opened_types_.insert(item_type1val);
11671  opened_types_.insert(item_type1compound);
11672  opened_types_.insert(field_types[i]);
11673 
11674  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[6]<1&&shape[7]>=1){
11676  hid_t item_type0;
11677  hsize_t shape01=shape[0];
11678  hid_t item_type1key;
11679  item_type1key=CreateFLStrType(shape[1]);
11680  hid_t item_type1val;
11681  hid_t item_type2elem;
11682  hid_t item_type3first;
11683  item_type3first=H5T_NATIVE_INT;
11684  hid_t item_type3second;
11685  hid_t item_type4first;
11686  item_type4first=sha1_type_;
11687  hid_t item_type4second;
11688  item_type4second=sha1_type_;
11689  hid_t item_type4secondcompound;
11690  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11691  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11692  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11693  hid_t item_type3elemcompound;
11694  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11695  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11696  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11697  item_type1val=sha1_type_;
11698  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
11699  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type3elemcompound);
11700  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
11701 
11702  }
11703  hid_t item_type1compound;
11704  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
11705  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11706  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11707  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11708  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
11709  field_types[i]=item_type0;
11710  opened_types_.insert(item_type4secondcompound);
11711  opened_types_.insert(item_type3elemcompound);
11712  opened_types_.insert(item_type1val);
11713  opened_types_.insert(item_type1compound);
11714  opened_types_.insert(field_types[i]);
11715 
11716  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[6]<1&&shape[7]<1){
11718  hid_t item_type0;
11719  hsize_t shape01=shape[0];
11720  hid_t item_type1key;
11721  item_type1key=CreateFLStrType(shape[1]);
11722  hid_t item_type1val;
11723  hid_t item_type2elem;
11724  hid_t item_type3first;
11725  item_type3first=H5T_NATIVE_INT;
11726  hid_t item_type3second;
11727  hid_t item_type4first;
11728  item_type4first=sha1_type_;
11729  hid_t item_type4second;
11730  item_type4second=sha1_type_;
11731  hid_t item_type4secondcompound;
11732  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11733  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11734  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11735  hid_t item_type3elemcompound;
11736  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11737  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11738  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11739  item_type1val=sha1_type_;
11740  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
11741  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
11742  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
11743 
11744  }
11745  hid_t item_type1compound;
11746  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
11747  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11748  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
11749  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11750  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
11751  field_types[i]=item_type0;
11752  opened_types_.insert(item_type4secondcompound);
11753  opened_types_.insert(item_type3elemcompound);
11754  opened_types_.insert(item_type1val);
11755  opened_types_.insert(item_type1compound);
11756  opened_types_.insert(field_types[i]);
11757 
11758  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[6]>=1&&shape[7]>=1){
11760  hid_t item_type0;
11761  hsize_t shape01=shape[0];
11762  hid_t item_type1key;
11763  item_type1key=sha1_type_;
11764  hid_t item_type1val;
11765  hsize_t shape02=shape[2];
11766  hid_t item_type2elem;
11767  hid_t item_type3first;
11768  item_type3first=H5T_NATIVE_INT;
11769  hid_t item_type3second;
11770  hid_t item_type4first;
11771  item_type4first=CreateFLStrType(shape[6]);
11772  hid_t item_type4second;
11773  item_type4second=CreateFLStrType(shape[7]);
11774  hid_t item_type4secondcompound;
11775  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+shape[7]);
11776  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11777  H5Tinsert(item_type4secondcompound, "second", 0+shape[6], item_type4second);
11778  hid_t item_type3elemcompound;
11779  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[6]+shape[7])));
11780  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11781  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11782  item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11783  hid_t item_type1compound;
11784  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]));
11785  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11786  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11787  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11788  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]))*shape[0]);
11789  field_types[i]=item_type0;
11790  opened_types_.insert(item_type4secondcompound);
11791  opened_types_.insert(item_type3elemcompound);
11792  opened_types_.insert(item_type1val);
11793  opened_types_.insert(item_type1compound);
11794  opened_types_.insert(field_types[i]);
11795 
11796  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[6]>=1&&shape[7]<1){
11798  hid_t item_type0;
11799  hsize_t shape01=shape[0];
11800  hid_t item_type1key;
11801  item_type1key=sha1_type_;
11802  hid_t item_type1val;
11803  hsize_t shape02=shape[2];
11804  hid_t item_type2elem;
11805  hid_t item_type3first;
11806  item_type3first=H5T_NATIVE_INT;
11807  hid_t item_type3second;
11808  hid_t item_type4first;
11809  item_type4first=CreateFLStrType(shape[6]);
11810  hid_t item_type4second;
11811  item_type4second=sha1_type_;
11812  hid_t item_type4secondcompound;
11813  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+CYCLUS_SHA1_SIZE);
11814  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11815  H5Tinsert(item_type4secondcompound, "second", 0+shape[6], item_type4second);
11816  hid_t item_type3elemcompound;
11817  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)));
11818  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11819  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11820  item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11821  hid_t item_type1compound;
11822  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]));
11823  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11824  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11825  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11826  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
11827  field_types[i]=item_type0;
11828  opened_types_.insert(item_type4secondcompound);
11829  opened_types_.insert(item_type3elemcompound);
11830  opened_types_.insert(item_type1val);
11831  opened_types_.insert(item_type1compound);
11832  opened_types_.insert(field_types[i]);
11833 
11834  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[6]<1&&shape[7]>=1){
11836  hid_t item_type0;
11837  hsize_t shape01=shape[0];
11838  hid_t item_type1key;
11839  item_type1key=sha1_type_;
11840  hid_t item_type1val;
11841  hsize_t shape02=shape[2];
11842  hid_t item_type2elem;
11843  hid_t item_type3first;
11844  item_type3first=H5T_NATIVE_INT;
11845  hid_t item_type3second;
11846  hid_t item_type4first;
11847  item_type4first=sha1_type_;
11848  hid_t item_type4second;
11849  item_type4second=CreateFLStrType(shape[7]);
11850  hid_t item_type4secondcompound;
11851  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[7]);
11852  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11853  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11854  hid_t item_type3elemcompound;
11855  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])));
11856  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11857  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11858  item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11859  hid_t item_type1compound;
11860  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]));
11861  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11862  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11863  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11864  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]))*shape[0]);
11865  field_types[i]=item_type0;
11866  opened_types_.insert(item_type4secondcompound);
11867  opened_types_.insert(item_type3elemcompound);
11868  opened_types_.insert(item_type1val);
11869  opened_types_.insert(item_type1compound);
11870  opened_types_.insert(field_types[i]);
11871 
11872  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[6]<1&&shape[7]<1){
11874  hid_t item_type0;
11875  hsize_t shape01=shape[0];
11876  hid_t item_type1key;
11877  item_type1key=sha1_type_;
11878  hid_t item_type1val;
11879  hsize_t shape02=shape[2];
11880  hid_t item_type2elem;
11881  hid_t item_type3first;
11882  item_type3first=H5T_NATIVE_INT;
11883  hid_t item_type3second;
11884  hid_t item_type4first;
11885  item_type4first=sha1_type_;
11886  hid_t item_type4second;
11887  item_type4second=sha1_type_;
11888  hid_t item_type4secondcompound;
11889  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11890  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11891  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11892  hid_t item_type3elemcompound;
11893  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11894  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11895  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11896  item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
11897  hid_t item_type1compound;
11898  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]));
11899  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11900  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11901  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11902  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
11903  field_types[i]=item_type0;
11904  opened_types_.insert(item_type4secondcompound);
11905  opened_types_.insert(item_type3elemcompound);
11906  opened_types_.insert(item_type1val);
11907  opened_types_.insert(item_type1compound);
11908  opened_types_.insert(field_types[i]);
11909 
11910  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[6]>=1&&shape[7]>=1){
11912  hid_t item_type0;
11913  hsize_t shape01=shape[0];
11914  hid_t item_type1key;
11915  item_type1key=sha1_type_;
11916  hid_t item_type1val;
11917  hid_t item_type2elem;
11918  hid_t item_type3first;
11919  item_type3first=H5T_NATIVE_INT;
11920  hid_t item_type3second;
11921  hid_t item_type4first;
11922  item_type4first=sha1_type_;
11923  hid_t item_type4second;
11924  item_type4second=sha1_type_;
11925  hid_t item_type4secondcompound;
11926  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11927  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11928  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11929  hid_t item_type3elemcompound;
11930  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11931  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11932  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11933  item_type1val=sha1_type_;
11934  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
11935  vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type3elemcompound);
11936  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
11937 
11938  }
11939  hid_t item_type1compound;
11940  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
11941  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11942  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11943  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11944  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
11945  field_types[i]=item_type0;
11946  opened_types_.insert(item_type4secondcompound);
11947  opened_types_.insert(item_type3elemcompound);
11948  opened_types_.insert(item_type1val);
11949  opened_types_.insert(item_type1compound);
11950  opened_types_.insert(field_types[i]);
11951 
11952  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[6]>=1&&shape[7]<1){
11954  hid_t item_type0;
11955  hsize_t shape01=shape[0];
11956  hid_t item_type1key;
11957  item_type1key=sha1_type_;
11958  hid_t item_type1val;
11959  hid_t item_type2elem;
11960  hid_t item_type3first;
11961  item_type3first=H5T_NATIVE_INT;
11962  hid_t item_type3second;
11963  hid_t item_type4first;
11964  item_type4first=sha1_type_;
11965  hid_t item_type4second;
11966  item_type4second=sha1_type_;
11967  hid_t item_type4secondcompound;
11968  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
11969  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
11970  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
11971  hid_t item_type3elemcompound;
11972  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
11973  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
11974  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
11975  item_type1val=sha1_type_;
11976  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
11977  vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
11978  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
11979 
11980  }
11981  hid_t item_type1compound;
11982  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
11983  H5Tinsert(item_type1compound, "key", 0, item_type1key);
11984  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
11985  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
11986  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
11987  field_types[i]=item_type0;
11988  opened_types_.insert(item_type4secondcompound);
11989  opened_types_.insert(item_type3elemcompound);
11990  opened_types_.insert(item_type1val);
11991  opened_types_.insert(item_type1compound);
11992  opened_types_.insert(field_types[i]);
11993 
11994  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[6]<1&&shape[7]>=1){
11996  hid_t item_type0;
11997  hsize_t shape01=shape[0];
11998  hid_t item_type1key;
11999  item_type1key=sha1_type_;
12000  hid_t item_type1val;
12001  hid_t item_type2elem;
12002  hid_t item_type3first;
12003  item_type3first=H5T_NATIVE_INT;
12004  hid_t item_type3second;
12005  hid_t item_type4first;
12006  item_type4first=sha1_type_;
12007  hid_t item_type4second;
12008  item_type4second=sha1_type_;
12009  hid_t item_type4secondcompound;
12010  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12011  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12012  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12013  hid_t item_type3elemcompound;
12014  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12015  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12016  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12017  item_type1val=sha1_type_;
12018  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
12019  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type3elemcompound);
12020  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12021 
12022  }
12023  hid_t item_type1compound;
12024  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12025  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12026  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12027  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12028  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
12029  field_types[i]=item_type0;
12030  opened_types_.insert(item_type4secondcompound);
12031  opened_types_.insert(item_type3elemcompound);
12032  opened_types_.insert(item_type1val);
12033  opened_types_.insert(item_type1compound);
12034  opened_types_.insert(field_types[i]);
12035 
12036  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[6]<1&&shape[7]<1){
12038  hid_t item_type0;
12039  hsize_t shape01=shape[0];
12040  hid_t item_type1key;
12041  item_type1key=sha1_type_;
12042  hid_t item_type1val;
12043  hid_t item_type2elem;
12044  hid_t item_type3first;
12045  item_type3first=H5T_NATIVE_INT;
12046  hid_t item_type3second;
12047  hid_t item_type4first;
12048  item_type4first=sha1_type_;
12049  hid_t item_type4second;
12050  item_type4second=sha1_type_;
12051  hid_t item_type4secondcompound;
12052  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12053  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12054  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12055  hid_t item_type3elemcompound;
12056  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12057  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12058  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12059  item_type1val=sha1_type_;
12060  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12061  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12062  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12063 
12064  }
12065  hid_t item_type1compound;
12066  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12067  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12068  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12069  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12070  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
12071  field_types[i]=item_type0;
12072  opened_types_.insert(item_type4secondcompound);
12073  opened_types_.insert(item_type3elemcompound);
12074  opened_types_.insert(item_type1val);
12075  opened_types_.insert(item_type1compound);
12076  opened_types_.insert(field_types[i]);
12077 
12078  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[6]>=1&&shape[7]>=1){
12080  hid_t item_type0;
12081  hid_t item_type1key;
12082  item_type1key=sha1_type_;
12083  hid_t item_type1val;
12084  hsize_t shape02=shape[2];
12085  hid_t item_type2elem;
12086  hid_t item_type3first;
12087  item_type3first=H5T_NATIVE_INT;
12088  hid_t item_type3second;
12089  hid_t item_type4first;
12090  item_type4first=sha1_type_;
12091  hid_t item_type4second;
12092  item_type4second=sha1_type_;
12093  hid_t item_type4secondcompound;
12094  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12095  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12096  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12097  hid_t item_type3elemcompound;
12098  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12099  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12100  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12101  item_type1val=sha1_type_;
12102  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12103  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12104  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12105 
12106  }
12107  hid_t item_type1compound;
12108  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12109  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12110  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12111  item_type0=sha1_type_;
12113  vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type1compound);
12114  opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
12115 
12116  }
12117  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12118  field_types[i]=sha1_type_;
12119 
12120  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[6]>=1&&shape[7]<1){
12122  hid_t item_type0;
12123  hid_t item_type1key;
12124  item_type1key=sha1_type_;
12125  hid_t item_type1val;
12126  hsize_t shape02=shape[2];
12127  hid_t item_type2elem;
12128  hid_t item_type3first;
12129  item_type3first=H5T_NATIVE_INT;
12130  hid_t item_type3second;
12131  hid_t item_type4first;
12132  item_type4first=sha1_type_;
12133  hid_t item_type4second;
12134  item_type4second=sha1_type_;
12135  hid_t item_type4secondcompound;
12136  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12137  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12138  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12139  hid_t item_type3elemcompound;
12140  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12141  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12142  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12143  item_type1val=sha1_type_;
12144  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12145  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12146  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12147 
12148  }
12149  hid_t item_type1compound;
12150  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12151  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12152  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12153  item_type0=sha1_type_;
12155  vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12156  opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
12157 
12158  }
12159  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12160  field_types[i]=sha1_type_;
12161 
12162  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[6]<1&&shape[7]>=1){
12164  hid_t item_type0;
12165  hid_t item_type1key;
12166  item_type1key=sha1_type_;
12167  hid_t item_type1val;
12168  hsize_t shape02=shape[2];
12169  hid_t item_type2elem;
12170  hid_t item_type3first;
12171  item_type3first=H5T_NATIVE_INT;
12172  hid_t item_type3second;
12173  hid_t item_type4first;
12174  item_type4first=sha1_type_;
12175  hid_t item_type4second;
12176  item_type4second=sha1_type_;
12177  hid_t item_type4secondcompound;
12178  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12179  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12180  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12181  hid_t item_type3elemcompound;
12182  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12183  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12184  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12185  item_type1val=sha1_type_;
12186  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12187  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12188  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12189 
12190  }
12191  hid_t item_type1compound;
12192  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12193  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12194  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12195  item_type0=sha1_type_;
12197  vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
12198  opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12199 
12200  }
12201  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12202  field_types[i]=sha1_type_;
12203 
12204  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[6]<1&&shape[7]<1){
12206  hid_t item_type0;
12207  hid_t item_type1key;
12208  item_type1key=sha1_type_;
12209  hid_t item_type1val;
12210  hsize_t shape02=shape[2];
12211  hid_t item_type2elem;
12212  hid_t item_type3first;
12213  item_type3first=H5T_NATIVE_INT;
12214  hid_t item_type3second;
12215  hid_t item_type4first;
12216  item_type4first=sha1_type_;
12217  hid_t item_type4second;
12218  item_type4second=sha1_type_;
12219  hid_t item_type4secondcompound;
12220  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12221  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12222  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12223  hid_t item_type3elemcompound;
12224  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12225  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12226  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12227  item_type1val=sha1_type_;
12228  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12229  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12230  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12231 
12232  }
12233  hid_t item_type1compound;
12234  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12235  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12236  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12237  item_type0=sha1_type_;
12239  vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12240  opened_types_.insert(vldts_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12241 
12242  }
12243  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12244  field_types[i]=sha1_type_;
12245 
12246  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[6]>=1&&shape[7]>=1){
12248  hid_t item_type0;
12249  hid_t item_type1key;
12250  item_type1key=sha1_type_;
12251  hid_t item_type1val;
12252  hid_t item_type2elem;
12253  hid_t item_type3first;
12254  item_type3first=H5T_NATIVE_INT;
12255  hid_t item_type3second;
12256  hid_t item_type4first;
12257  item_type4first=sha1_type_;
12258  hid_t item_type4second;
12259  item_type4second=sha1_type_;
12260  hid_t item_type4secondcompound;
12261  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12262  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12263  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12264  hid_t item_type3elemcompound;
12265  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12266  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12267  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12268  item_type1val=sha1_type_;
12269  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12270  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12271  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12272 
12273  }
12274  hid_t item_type1compound;
12275  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12276  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12277  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12278  item_type0=sha1_type_;
12280  vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type1compound);
12281  opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
12282 
12283  }
12284  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12285  field_types[i]=sha1_type_;
12286 
12287  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[6]>=1&&shape[7]<1){
12289  hid_t item_type0;
12290  hid_t item_type1key;
12291  item_type1key=sha1_type_;
12292  hid_t item_type1val;
12293  hid_t item_type2elem;
12294  hid_t item_type3first;
12295  item_type3first=H5T_NATIVE_INT;
12296  hid_t item_type3second;
12297  hid_t item_type4first;
12298  item_type4first=sha1_type_;
12299  hid_t item_type4second;
12300  item_type4second=sha1_type_;
12301  hid_t item_type4secondcompound;
12302  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12303  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12304  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12305  hid_t item_type3elemcompound;
12306  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12307  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12308  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12309  item_type1val=sha1_type_;
12310  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12311  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12312  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12313 
12314  }
12315  hid_t item_type1compound;
12316  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12317  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12318  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12319  item_type0=sha1_type_;
12321  vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12322  opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
12323 
12324  }
12325  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12326  field_types[i]=sha1_type_;
12327 
12328  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[6]<1&&shape[7]>=1){
12330  hid_t item_type0;
12331  hid_t item_type1key;
12332  item_type1key=sha1_type_;
12333  hid_t item_type1val;
12334  hid_t item_type2elem;
12335  hid_t item_type3first;
12336  item_type3first=H5T_NATIVE_INT;
12337  hid_t item_type3second;
12338  hid_t item_type4first;
12339  item_type4first=sha1_type_;
12340  hid_t item_type4second;
12341  item_type4second=sha1_type_;
12342  hid_t item_type4secondcompound;
12343  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12344  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12345  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12346  hid_t item_type3elemcompound;
12347  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12348  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12349  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12350  item_type1val=sha1_type_;
12351  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12352  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12353  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12354 
12355  }
12356  hid_t item_type1compound;
12357  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12358  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12359  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12360  item_type0=sha1_type_;
12362  vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
12363  opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12364 
12365  }
12366  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12367  field_types[i]=sha1_type_;
12368 
12369  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[6]<1&&shape[7]<1){
12371  hid_t item_type0;
12372  hid_t item_type1key;
12373  item_type1key=sha1_type_;
12374  hid_t item_type1val;
12375  hid_t item_type2elem;
12376  hid_t item_type3first;
12377  item_type3first=H5T_NATIVE_INT;
12378  hid_t item_type3second;
12379  hid_t item_type4first;
12380  item_type4first=sha1_type_;
12381  hid_t item_type4second;
12382  item_type4second=sha1_type_;
12383  hid_t item_type4secondcompound;
12384  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12385  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12386  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12387  hid_t item_type3elemcompound;
12388  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12389  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12390  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12391  item_type1val=sha1_type_;
12392  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12393  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12394  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12395 
12396  }
12397  hid_t item_type1compound;
12398  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12399  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12400  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12401  item_type0=sha1_type_;
12403  vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12404  opened_types_.insert(vldts_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12405 
12406  }
12407  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12408  field_types[i]=sha1_type_;
12409 
12410  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[6]>=1&&shape[7]>=1){
12412  hid_t item_type0;
12413  hid_t item_type1key;
12414  item_type1key=sha1_type_;
12415  hid_t item_type1val;
12416  hsize_t shape02=shape[2];
12417  hid_t item_type2elem;
12418  hid_t item_type3first;
12419  item_type3first=H5T_NATIVE_INT;
12420  hid_t item_type3second;
12421  hid_t item_type4first;
12422  item_type4first=sha1_type_;
12423  hid_t item_type4second;
12424  item_type4second=sha1_type_;
12425  hid_t item_type4secondcompound;
12426  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12427  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12428  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12429  hid_t item_type3elemcompound;
12430  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12431  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12432  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12433  item_type1val=sha1_type_;
12434  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12435  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12436  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12437 
12438  }
12439  hid_t item_type1compound;
12440  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12441  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12442  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12443  item_type0=sha1_type_;
12445  vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type1compound);
12446  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
12447 
12448  }
12449  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12450  field_types[i]=sha1_type_;
12451 
12452  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[6]>=1&&shape[7]<1){
12454  hid_t item_type0;
12455  hid_t item_type1key;
12456  item_type1key=sha1_type_;
12457  hid_t item_type1val;
12458  hsize_t shape02=shape[2];
12459  hid_t item_type2elem;
12460  hid_t item_type3first;
12461  item_type3first=H5T_NATIVE_INT;
12462  hid_t item_type3second;
12463  hid_t item_type4first;
12464  item_type4first=sha1_type_;
12465  hid_t item_type4second;
12466  item_type4second=sha1_type_;
12467  hid_t item_type4secondcompound;
12468  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12469  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12470  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12471  hid_t item_type3elemcompound;
12472  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12473  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12474  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12475  item_type1val=sha1_type_;
12476  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12477  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12478  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12479 
12480  }
12481  hid_t item_type1compound;
12482  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12483  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12484  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12485  item_type0=sha1_type_;
12487  vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12488  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
12489 
12490  }
12491  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12492  field_types[i]=sha1_type_;
12493 
12494  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[6]<1&&shape[7]>=1){
12496  hid_t item_type0;
12497  hid_t item_type1key;
12498  item_type1key=sha1_type_;
12499  hid_t item_type1val;
12500  hsize_t shape02=shape[2];
12501  hid_t item_type2elem;
12502  hid_t item_type3first;
12503  item_type3first=H5T_NATIVE_INT;
12504  hid_t item_type3second;
12505  hid_t item_type4first;
12506  item_type4first=sha1_type_;
12507  hid_t item_type4second;
12508  item_type4second=sha1_type_;
12509  hid_t item_type4secondcompound;
12510  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12511  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12512  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12513  hid_t item_type3elemcompound;
12514  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12515  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12516  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12517  item_type1val=sha1_type_;
12518  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12519  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12520  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12521 
12522  }
12523  hid_t item_type1compound;
12524  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12525  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12526  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12527  item_type0=sha1_type_;
12529  vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
12530  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12531 
12532  }
12533  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12534  field_types[i]=sha1_type_;
12535 
12536  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[6]<1&&shape[7]<1){
12538  hid_t item_type0;
12539  hid_t item_type1key;
12540  item_type1key=sha1_type_;
12541  hid_t item_type1val;
12542  hsize_t shape02=shape[2];
12543  hid_t item_type2elem;
12544  hid_t item_type3first;
12545  item_type3first=H5T_NATIVE_INT;
12546  hid_t item_type3second;
12547  hid_t item_type4first;
12548  item_type4first=sha1_type_;
12549  hid_t item_type4second;
12550  item_type4second=sha1_type_;
12551  hid_t item_type4secondcompound;
12552  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12553  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12554  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12555  hid_t item_type3elemcompound;
12556  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12557  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12558  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12559  item_type1val=sha1_type_;
12560  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12561  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12562  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12563 
12564  }
12565  hid_t item_type1compound;
12566  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12567  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12568  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12569  item_type0=sha1_type_;
12571  vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12572  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12573 
12574  }
12575  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12576  field_types[i]=sha1_type_;
12577 
12578  }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[6]>=1&&shape[7]>=1){
12580  hid_t item_type0;
12581  hid_t item_type1key;
12582  item_type1key=sha1_type_;
12583  hid_t item_type1val;
12584  hid_t item_type2elem;
12585  hid_t item_type3first;
12586  item_type3first=H5T_NATIVE_INT;
12587  hid_t item_type3second;
12588  hid_t item_type4first;
12589  item_type4first=sha1_type_;
12590  hid_t item_type4second;
12591  item_type4second=sha1_type_;
12592  hid_t item_type4secondcompound;
12593  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12594  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12595  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12596  hid_t item_type3elemcompound;
12597  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12598  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12599  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12600  item_type1val=sha1_type_;
12601  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12602  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12603  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12604 
12605  }
12606  hid_t item_type1compound;
12607  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12608  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12609  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12610  item_type0=sha1_type_;
12612  vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type1compound);
12613  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
12614 
12615  }
12616  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12617  field_types[i]=sha1_type_;
12618 
12619  }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[6]>=1&&shape[7]<1){
12621  hid_t item_type0;
12622  hid_t item_type1key;
12623  item_type1key=sha1_type_;
12624  hid_t item_type1val;
12625  hid_t item_type2elem;
12626  hid_t item_type3first;
12627  item_type3first=H5T_NATIVE_INT;
12628  hid_t item_type3second;
12629  hid_t item_type4first;
12630  item_type4first=sha1_type_;
12631  hid_t item_type4second;
12632  item_type4second=sha1_type_;
12633  hid_t item_type4secondcompound;
12634  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12635  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12636  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12637  hid_t item_type3elemcompound;
12638  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12639  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12640  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12641  item_type1val=sha1_type_;
12642  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12643  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12644  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12645 
12646  }
12647  hid_t item_type1compound;
12648  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12649  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12650  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12651  item_type0=sha1_type_;
12653  vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type1compound);
12654  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
12655 
12656  }
12657  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12658  field_types[i]=sha1_type_;
12659 
12660  }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[6]<1&&shape[7]>=1){
12662  hid_t item_type0;
12663  hid_t item_type1key;
12664  item_type1key=sha1_type_;
12665  hid_t item_type1val;
12666  hid_t item_type2elem;
12667  hid_t item_type3first;
12668  item_type3first=H5T_NATIVE_INT;
12669  hid_t item_type3second;
12670  hid_t item_type4first;
12671  item_type4first=sha1_type_;
12672  hid_t item_type4second;
12673  item_type4second=sha1_type_;
12674  hid_t item_type4secondcompound;
12675  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
12676  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12677  H5Tinsert(item_type4secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type4second);
12678  hid_t item_type3elemcompound;
12679  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
12680  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12681  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12682  item_type1val=sha1_type_;
12683  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
12684  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type3elemcompound);
12685  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
12686 
12687  }
12688  hid_t item_type1compound;
12689  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12690  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12691  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
12692  item_type0=sha1_type_;
12694  vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type1compound);
12695  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
12696 
12697  }
12698  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12699  field_types[i]=sha1_type_;
12700 
12701  }else{
12703  hid_t item_type0;
12704  hsize_t shape01=shape[0];
12705  hid_t item_type1key;
12706  item_type1key=CreateFLStrType(shape[1]);
12707  hid_t item_type1val;
12708  hsize_t shape02=shape[2];
12709  hid_t item_type2elem;
12710  hid_t item_type3first;
12711  item_type3first=H5T_NATIVE_INT;
12712  hid_t item_type3second;
12713  hid_t item_type4first;
12714  item_type4first=CreateFLStrType(shape[6]);
12715  hid_t item_type4second;
12716  item_type4second=CreateFLStrType(shape[7]);
12717  hid_t item_type4secondcompound;
12718  item_type4secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+shape[7]);
12719  H5Tinsert(item_type4secondcompound, "first", 0, item_type4first);
12720  H5Tinsert(item_type4secondcompound, "second", 0+shape[6], item_type4second);
12721  hid_t item_type3elemcompound;
12722  item_type3elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[6]+shape[7])));
12723  H5Tinsert(item_type3elemcompound, "first", 0, item_type3first);
12724  H5Tinsert(item_type3elemcompound, "second", 0+sizeof(int), item_type4secondcompound);
12725  item_type1val=H5Tarray_create2(item_type3elemcompound, 1, &shape02);
12726  hid_t item_type1compound;
12727  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]));
12728  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12729  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
12730  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12731  dst_sizes[i]=((shape[1]+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]))*shape[0]);
12732  field_types[i]=item_type0;
12733  opened_types_.insert(item_type4secondcompound);
12734  opened_types_.insert(item_type3elemcompound);
12735  opened_types_.insert(item_type1val);
12736  opened_types_.insert(item_type1compound);
12737  opened_types_.insert(field_types[i]);
12738 
12739  }
12740 
12741  }else if(valtype==typeid(std::list<std::pair<int, int>>)){
12742  shape=shapes[i];
12743  if(shape.empty()||shape[0]<1){
12744  dbtypes[i]=VL_LIST_PAIR_INT_INT;
12745  hid_t item_type0;
12746  hid_t item_type1elem;
12747  hid_t item_type2first;
12748  item_type2first=H5T_NATIVE_INT;
12749  hid_t item_type2second;
12750  item_type2second=H5T_NATIVE_INT;
12751  hid_t item_type2elemcompound;
12752  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
12753  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
12754  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type2second);
12755  item_type0=sha1_type_;
12756  if(vldts_.count(VL_LIST_PAIR_INT_INT)==0){
12757  vldts_[VL_LIST_PAIR_INT_INT]=H5Tvlen_create(item_type2elemcompound);
12758  opened_types_.insert(vldts_[VL_LIST_PAIR_INT_INT]);
12759 
12760  }
12761  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12762  field_types[i]=sha1_type_;
12763 
12764  }else{
12765  dbtypes[i]=LIST_PAIR_INT_INT;
12766  hid_t item_type0;
12767  hsize_t shape01=shape[0];
12768  hid_t item_type1elem;
12769  hid_t item_type2first;
12770  item_type2first=H5T_NATIVE_INT;
12771  hid_t item_type2second;
12772  item_type2second=H5T_NATIVE_INT;
12773  hid_t item_type2elemcompound;
12774  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(int));
12775  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
12776  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type2second);
12777  item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
12778  dst_sizes[i]=((((sizeof(int)+sizeof(int))))*shape[0]);
12779  field_types[i]=item_type0;
12780  opened_types_.insert(item_type2elemcompound);
12781  opened_types_.insert(field_types[i]);
12782 
12783  }
12784 
12785  }else if(valtype==typeid(std::map<std::string, std::pair<std::string, std::vector<double>>>)){
12786  shape=shapes[i];
12787  if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[3]<1&&shape[4]<1){
12789  hid_t item_type0;
12790  hid_t item_type1key;
12791  item_type1key=sha1_type_;
12792  hid_t item_type1val;
12793  hid_t item_type2first;
12794  item_type2first=sha1_type_;
12795  hid_t item_type2second;
12796  hid_t item_type3elem;
12797  item_type3elem=H5T_NATIVE_DOUBLE;
12798  item_type2second=sha1_type_;
12799  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
12800  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
12801  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
12802 
12803  }
12804  hid_t item_type2valcompound;
12805  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12806  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12807  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
12808  hid_t item_type1compound;
12809  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
12810  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12811  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
12812  item_type0=sha1_type_;
12814  vldts_[VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
12815  opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE]);
12816 
12817  }
12818  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
12819  field_types[i]=sha1_type_;
12820 
12821  }else if(shape[0]>=1&&shape[1]>=1&&shape[3]>=1&&shape[4]<1){
12823  hid_t item_type0;
12824  hsize_t shape01=shape[0];
12825  hid_t item_type1key;
12826  item_type1key=CreateFLStrType(shape[1]);
12827  hid_t item_type1val;
12828  hid_t item_type2first;
12829  item_type2first=CreateFLStrType(shape[3]);
12830  hid_t item_type2second;
12831  hid_t item_type3elem;
12832  item_type3elem=H5T_NATIVE_DOUBLE;
12833  item_type2second=sha1_type_;
12834  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
12835  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
12836  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
12837 
12838  }
12839  hid_t item_type2valcompound;
12840  item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+(CYCLUS_SHA1_SIZE));
12841  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12842  H5Tinsert(item_type2valcompound, "second", 0+shape[3], item_type2second);
12843  hid_t item_type1compound;
12844  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((shape[3]+(CYCLUS_SHA1_SIZE))));
12845  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12846  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
12847  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12848  dst_sizes[i]=((shape[1]+((shape[3]+(CYCLUS_SHA1_SIZE))))*shape[0]);
12849  field_types[i]=item_type0;
12850  opened_types_.insert(item_type2second);
12851  opened_types_.insert(item_type2valcompound);
12852  opened_types_.insert(item_type1compound);
12853  opened_types_.insert(field_types[i]);
12854 
12855  }else if(shape[0]>=1&&shape[1]>=1&&shape[3]<1&&shape[4]>=1){
12857  hid_t item_type0;
12858  hsize_t shape01=shape[0];
12859  hid_t item_type1key;
12860  item_type1key=CreateFLStrType(shape[1]);
12861  hid_t item_type1val;
12862  hid_t item_type2first;
12863  item_type2first=sha1_type_;
12864  hid_t item_type2second;
12865  hsize_t shape03=shape[4];
12866  hid_t item_type3elem;
12867  item_type3elem=H5T_NATIVE_DOUBLE;
12868  item_type2second=H5Tarray_create2(item_type3elem, 1, &shape03);
12869  hid_t item_type2valcompound;
12870  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]));
12871  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12872  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
12873  hid_t item_type1compound;
12874  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))));
12875  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12876  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
12877  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12878  dst_sizes[i]=((shape[1]+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))))*shape[0]);
12879  field_types[i]=item_type0;
12880  opened_types_.insert(item_type2second);
12881  opened_types_.insert(item_type2valcompound);
12882  opened_types_.insert(item_type1compound);
12883  opened_types_.insert(field_types[i]);
12884 
12885  }else if(shape[0]>=1&&shape[1]>=1&&shape[3]<1&&shape[4]<1){
12887  hid_t item_type0;
12888  hsize_t shape01=shape[0];
12889  hid_t item_type1key;
12890  item_type1key=CreateFLStrType(shape[1]);
12891  hid_t item_type1val;
12892  hid_t item_type2first;
12893  item_type2first=sha1_type_;
12894  hid_t item_type2second;
12895  hid_t item_type3elem;
12896  item_type3elem=H5T_NATIVE_DOUBLE;
12897  item_type2second=sha1_type_;
12898  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
12899  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
12900  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
12901 
12902  }
12903  hid_t item_type2valcompound;
12904  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
12905  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12906  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
12907  hid_t item_type1compound;
12908  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
12909  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12910  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
12911  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12912  dst_sizes[i]=((shape[1]+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))))*shape[0]);
12913  field_types[i]=item_type0;
12914  opened_types_.insert(item_type2second);
12915  opened_types_.insert(item_type2valcompound);
12916  opened_types_.insert(item_type1compound);
12917  opened_types_.insert(field_types[i]);
12918 
12919  }else if(shape[0]>=1&&shape[1]<1&&shape[3]>=1&&shape[4]>=1){
12921  hid_t item_type0;
12922  hsize_t shape01=shape[0];
12923  hid_t item_type1key;
12924  item_type1key=sha1_type_;
12925  hid_t item_type1val;
12926  hid_t item_type2first;
12927  item_type2first=CreateFLStrType(shape[3]);
12928  hid_t item_type2second;
12929  hsize_t shape03=shape[4];
12930  hid_t item_type3elem;
12931  item_type3elem=H5T_NATIVE_DOUBLE;
12932  item_type2second=H5Tarray_create2(item_type3elem, 1, &shape03);
12933  hid_t item_type2valcompound;
12934  item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+((sizeof(double))*shape[4]));
12935  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12936  H5Tinsert(item_type2valcompound, "second", 0+shape[3], item_type2second);
12937  hid_t item_type1compound;
12938  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((shape[3]+((sizeof(double))*shape[4]))));
12939  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12940  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
12941  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12942  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((shape[3]+((sizeof(double))*shape[4]))))*shape[0]);
12943  field_types[i]=item_type0;
12944  opened_types_.insert(item_type2second);
12945  opened_types_.insert(item_type2valcompound);
12946  opened_types_.insert(item_type1compound);
12947  opened_types_.insert(field_types[i]);
12948 
12949  }else if(shape[0]>=1&&shape[1]<1&&shape[3]<1&&shape[4]>=1){
12951  hid_t item_type0;
12952  hsize_t shape01=shape[0];
12953  hid_t item_type1key;
12954  item_type1key=sha1_type_;
12955  hid_t item_type1val;
12956  hid_t item_type2first;
12957  item_type2first=sha1_type_;
12958  hid_t item_type2second;
12959  hsize_t shape03=shape[4];
12960  hid_t item_type3elem;
12961  item_type3elem=H5T_NATIVE_DOUBLE;
12962  item_type2second=H5Tarray_create2(item_type3elem, 1, &shape03);
12963  hid_t item_type2valcompound;
12964  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]));
12965  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
12966  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
12967  hid_t item_type1compound;
12968  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))));
12969  H5Tinsert(item_type1compound, "key", 0, item_type1key);
12970  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
12971  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
12972  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))))*shape[0]);
12973  field_types[i]=item_type0;
12974  opened_types_.insert(item_type2second);
12975  opened_types_.insert(item_type2valcompound);
12976  opened_types_.insert(item_type1compound);
12977  opened_types_.insert(field_types[i]);
12978 
12979  }else if(shape[0]>=1&&shape[1]<1&&shape[3]>=1&&shape[4]<1){
12981  hid_t item_type0;
12982  hsize_t shape01=shape[0];
12983  hid_t item_type1key;
12984  item_type1key=sha1_type_;
12985  hid_t item_type1val;
12986  hid_t item_type2first;
12987  item_type2first=CreateFLStrType(shape[3]);
12988  hid_t item_type2second;
12989  hid_t item_type3elem;
12990  item_type3elem=H5T_NATIVE_DOUBLE;
12991  item_type2second=sha1_type_;
12992  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
12993  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
12994  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
12995 
12996  }
12997  hid_t item_type2valcompound;
12998  item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+(CYCLUS_SHA1_SIZE));
12999  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13000  H5Tinsert(item_type2valcompound, "second", 0+shape[3], item_type2second);
13001  hid_t item_type1compound;
13002  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((shape[3]+(CYCLUS_SHA1_SIZE))));
13003  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13004  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13005  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13006  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((shape[3]+(CYCLUS_SHA1_SIZE))))*shape[0]);
13007  field_types[i]=item_type0;
13008  opened_types_.insert(item_type2second);
13009  opened_types_.insert(item_type2valcompound);
13010  opened_types_.insert(item_type1compound);
13011  opened_types_.insert(field_types[i]);
13012 
13013  }else if(shape[0]>=1&&shape[1]<1&&shape[3]<1&&shape[4]<1){
13015  hid_t item_type0;
13016  hsize_t shape01=shape[0];
13017  hid_t item_type1key;
13018  item_type1key=sha1_type_;
13019  hid_t item_type1val;
13020  hid_t item_type2first;
13021  item_type2first=sha1_type_;
13022  hid_t item_type2second;
13023  hid_t item_type3elem;
13024  item_type3elem=H5T_NATIVE_DOUBLE;
13025  item_type2second=sha1_type_;
13026  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13027  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13028  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13029 
13030  }
13031  hid_t item_type2valcompound;
13032  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13033  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13034  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13035  hid_t item_type1compound;
13036  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13037  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13038  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13039  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13040  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))))*shape[0]);
13041  field_types[i]=item_type0;
13042  opened_types_.insert(item_type2second);
13043  opened_types_.insert(item_type2valcompound);
13044  opened_types_.insert(item_type1compound);
13045  opened_types_.insert(field_types[i]);
13046 
13047  }else if(shape[0]<1&&shape[1]>=1&&shape[3]>=1&&shape[4]>=1){
13049  hid_t item_type0;
13050  hid_t item_type1key;
13051  item_type1key=sha1_type_;
13052  hid_t item_type1val;
13053  hid_t item_type2first;
13054  item_type2first=sha1_type_;
13055  hid_t item_type2second;
13056  hsize_t shape03=shape[4];
13057  hid_t item_type3elem;
13058  item_type3elem=H5T_NATIVE_DOUBLE;
13059  item_type2second=sha1_type_;
13060  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13061  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13062  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13063 
13064  }
13065  hid_t item_type2valcompound;
13066  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13067  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13068  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13069  hid_t item_type1compound;
13070  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13071  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13072  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13073  item_type0=sha1_type_;
13074  if(vldts_.count(VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE)==0){
13075  vldts_[VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13076  opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE]);
13077 
13078  }
13079  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13080  field_types[i]=sha1_type_;
13081 
13082  }else if(shape[0]<1&&shape[1]<1&&shape[3]>=1&&shape[4]>=1){
13084  hid_t item_type0;
13085  hid_t item_type1key;
13086  item_type1key=sha1_type_;
13087  hid_t item_type1val;
13088  hid_t item_type2first;
13089  item_type2first=sha1_type_;
13090  hid_t item_type2second;
13091  hsize_t shape03=shape[4];
13092  hid_t item_type3elem;
13093  item_type3elem=H5T_NATIVE_DOUBLE;
13094  item_type2second=sha1_type_;
13095  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13096  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13097  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13098 
13099  }
13100  hid_t item_type2valcompound;
13101  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13102  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13103  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13104  hid_t item_type1compound;
13105  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13106  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13107  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13108  item_type0=sha1_type_;
13109  if(vldts_.count(VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE)==0){
13110  vldts_[VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13111  opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE]);
13112 
13113  }
13114  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13115  field_types[i]=sha1_type_;
13116 
13117  }else if(shape[0]<1&&shape[1]>=1&&shape[3]<1&&shape[4]>=1){
13119  hid_t item_type0;
13120  hid_t item_type1key;
13121  item_type1key=sha1_type_;
13122  hid_t item_type1val;
13123  hid_t item_type2first;
13124  item_type2first=sha1_type_;
13125  hid_t item_type2second;
13126  hsize_t shape03=shape[4];
13127  hid_t item_type3elem;
13128  item_type3elem=H5T_NATIVE_DOUBLE;
13129  item_type2second=sha1_type_;
13130  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13131  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13132  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13133 
13134  }
13135  hid_t item_type2valcompound;
13136  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13137  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13138  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13139  hid_t item_type1compound;
13140  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13141  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13142  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13143  item_type0=sha1_type_;
13144  if(vldts_.count(VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE)==0){
13145  vldts_[VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13146  opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE]);
13147 
13148  }
13149  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13150  field_types[i]=sha1_type_;
13151 
13152  }else if(shape[0]<1&&shape[1]>=1&&shape[3]>=1&&shape[4]<1){
13154  hid_t item_type0;
13155  hid_t item_type1key;
13156  item_type1key=sha1_type_;
13157  hid_t item_type1val;
13158  hid_t item_type2first;
13159  item_type2first=sha1_type_;
13160  hid_t item_type2second;
13161  hid_t item_type3elem;
13162  item_type3elem=H5T_NATIVE_DOUBLE;
13163  item_type2second=sha1_type_;
13164  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13165  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13166  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13167 
13168  }
13169  hid_t item_type2valcompound;
13170  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13171  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13172  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13173  hid_t item_type1compound;
13174  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13175  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13176  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13177  item_type0=sha1_type_;
13178  if(vldts_.count(VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE)==0){
13179  vldts_[VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13180  opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE]);
13181 
13182  }
13183  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13184  field_types[i]=sha1_type_;
13185 
13186  }else if(shape[0]<1&&shape[1]<1&&shape[3]<1&&shape[4]>=1){
13188  hid_t item_type0;
13189  hid_t item_type1key;
13190  item_type1key=sha1_type_;
13191  hid_t item_type1val;
13192  hid_t item_type2first;
13193  item_type2first=sha1_type_;
13194  hid_t item_type2second;
13195  hsize_t shape03=shape[4];
13196  hid_t item_type3elem;
13197  item_type3elem=H5T_NATIVE_DOUBLE;
13198  item_type2second=sha1_type_;
13199  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13200  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13201  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13202 
13203  }
13204  hid_t item_type2valcompound;
13205  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13206  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13207  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13208  hid_t item_type1compound;
13209  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13210  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13211  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13212  item_type0=sha1_type_;
13213  if(vldts_.count(VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE)==0){
13214  vldts_[VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13215  opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE]);
13216 
13217  }
13218  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13219  field_types[i]=sha1_type_;
13220 
13221  }else if(shape[0]<1&&shape[1]<1&&shape[3]>=1&&shape[4]<1){
13223  hid_t item_type0;
13224  hid_t item_type1key;
13225  item_type1key=sha1_type_;
13226  hid_t item_type1val;
13227  hid_t item_type2first;
13228  item_type2first=sha1_type_;
13229  hid_t item_type2second;
13230  hid_t item_type3elem;
13231  item_type3elem=H5T_NATIVE_DOUBLE;
13232  item_type2second=sha1_type_;
13233  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13234  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13235  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13236 
13237  }
13238  hid_t item_type2valcompound;
13239  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13240  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13241  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13242  hid_t item_type1compound;
13243  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13244  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13245  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13246  item_type0=sha1_type_;
13247  if(vldts_.count(VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE)==0){
13248  vldts_[VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13249  opened_types_.insert(vldts_[VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE]);
13250 
13251  }
13252  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13253  field_types[i]=sha1_type_;
13254 
13255  }else if(shape[0]<1&&shape[1]>=1&&shape[3]<1&&shape[4]<1){
13257  hid_t item_type0;
13258  hid_t item_type1key;
13259  item_type1key=sha1_type_;
13260  hid_t item_type1val;
13261  hid_t item_type2first;
13262  item_type2first=sha1_type_;
13263  hid_t item_type2second;
13264  hid_t item_type3elem;
13265  item_type3elem=H5T_NATIVE_DOUBLE;
13266  item_type2second=sha1_type_;
13267  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
13268  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type3elem);
13269  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
13270 
13271  }
13272  hid_t item_type2valcompound;
13273  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13274  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13275  H5Tinsert(item_type2valcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
13276  hid_t item_type1compound;
13277  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))));
13278  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13279  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type2valcompound);
13280  item_type0=sha1_type_;
13281  if(vldts_.count(VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE)==0){
13282  vldts_[VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type1compound);
13283  opened_types_.insert(vldts_[VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE]);
13284 
13285  }
13286  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13287  field_types[i]=sha1_type_;
13288 
13289  }else{
13291  hid_t item_type0;
13292  hsize_t shape01=shape[0];
13293  hid_t item_type1key;
13294  item_type1key=CreateFLStrType(shape[1]);
13295  hid_t item_type1val;
13296  hid_t item_type2first;
13297  item_type2first=CreateFLStrType(shape[3]);
13298  hid_t item_type2second;
13299  hsize_t shape03=shape[4];
13300  hid_t item_type3elem;
13301  item_type3elem=H5T_NATIVE_DOUBLE;
13302  item_type2second=H5Tarray_create2(item_type3elem, 1, &shape03);
13303  hid_t item_type2valcompound;
13304  item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+((sizeof(double))*shape[4]));
13305  H5Tinsert(item_type2valcompound, "first", 0, item_type2first);
13306  H5Tinsert(item_type2valcompound, "second", 0+shape[3], item_type2second);
13307  hid_t item_type1compound;
13308  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((shape[3]+((sizeof(double))*shape[4]))));
13309  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13310  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type2valcompound);
13311  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13312  dst_sizes[i]=((shape[1]+((shape[3]+((sizeof(double))*shape[4]))))*shape[0]);
13313  field_types[i]=item_type0;
13314  opened_types_.insert(item_type2second);
13315  opened_types_.insert(item_type2valcompound);
13316  opened_types_.insert(item_type1compound);
13317  opened_types_.insert(field_types[i]);
13318 
13319  }
13320 
13321  }else if(valtype==typeid(std::map<std::string, std::map<std::string, int>>)){
13322  shape=shapes[i];
13323  if(shape.empty()||shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[3]<1){
13325  hid_t item_type0;
13326  hid_t item_type1key;
13327  item_type1key=sha1_type_;
13328  hid_t item_type1val;
13329  hid_t item_type2key;
13330  item_type2key=sha1_type_;
13331  hid_t item_type2val;
13332  item_type2val=H5T_NATIVE_INT;
13333  hid_t item_type2valcompound;
13334  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13335  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13336  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13337  item_type1val=sha1_type_;
13338  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13339  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13340  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13341 
13342  }
13343  hid_t item_type1compound;
13344  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13345  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13346  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13347  item_type0=sha1_type_;
13348  if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT)==0){
13349  vldts_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
13350  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT]);
13351 
13352  }
13353  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13354  field_types[i]=sha1_type_;
13355 
13356  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]>=1&&shape[3]<1){
13357  dbtypes[i]=MAP_STRING_MAP_VL_STRING_INT;
13358  hid_t item_type0;
13359  hsize_t shape01=shape[0];
13360  hid_t item_type1key;
13361  item_type1key=CreateFLStrType(shape[1]);
13362  hid_t item_type1val;
13363  hsize_t shape02=shape[2];
13364  hid_t item_type2key;
13365  item_type2key=sha1_type_;
13366  hid_t item_type2val;
13367  item_type2val=H5T_NATIVE_INT;
13368  hid_t item_type2valcompound;
13369  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13370  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13371  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13372  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
13373  hid_t item_type1compound;
13374  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]));
13375  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13376  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
13377  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13378  dst_sizes[i]=((shape[1]+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]))*shape[0]);
13379  field_types[i]=item_type0;
13380  opened_types_.insert(item_type2valcompound);
13381  opened_types_.insert(item_type1val);
13382  opened_types_.insert(item_type1compound);
13383  opened_types_.insert(field_types[i]);
13384 
13385  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[3]>=1){
13386  dbtypes[i]=MAP_STRING_VL_MAP_STRING_INT;
13387  hid_t item_type0;
13388  hsize_t shape01=shape[0];
13389  hid_t item_type1key;
13390  item_type1key=CreateFLStrType(shape[1]);
13391  hid_t item_type1val;
13392  hid_t item_type2key;
13393  item_type2key=sha1_type_;
13394  hid_t item_type2val;
13395  item_type2val=H5T_NATIVE_INT;
13396  hid_t item_type2valcompound;
13397  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13398  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13399  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13400  item_type1val=sha1_type_;
13401  if(vldts_.count(VL_MAP_STRING_INT)==0){
13402  vldts_[VL_MAP_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13403  opened_types_.insert(vldts_[VL_MAP_STRING_INT]);
13404 
13405  }
13406  hid_t item_type1compound;
13407  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
13408  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13409  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
13410  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13411  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
13412  field_types[i]=item_type0;
13413  opened_types_.insert(item_type2valcompound);
13414  opened_types_.insert(item_type1val);
13415  opened_types_.insert(item_type1compound);
13416  opened_types_.insert(field_types[i]);
13417 
13418  }else if(shape[0]>=1&&shape[1]>=1&&shape[2]<1&&shape[3]<1){
13420  hid_t item_type0;
13421  hsize_t shape01=shape[0];
13422  hid_t item_type1key;
13423  item_type1key=CreateFLStrType(shape[1]);
13424  hid_t item_type1val;
13425  hid_t item_type2key;
13426  item_type2key=sha1_type_;
13427  hid_t item_type2val;
13428  item_type2val=H5T_NATIVE_INT;
13429  hid_t item_type2valcompound;
13430  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13431  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13432  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13433  item_type1val=sha1_type_;
13434  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13435  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13436  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13437 
13438  }
13439  hid_t item_type1compound;
13440  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
13441  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13442  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
13443  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13444  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
13445  field_types[i]=item_type0;
13446  opened_types_.insert(item_type2valcompound);
13447  opened_types_.insert(item_type1val);
13448  opened_types_.insert(item_type1compound);
13449  opened_types_.insert(field_types[i]);
13450 
13451  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[3]>=1){
13452  dbtypes[i]=MAP_VL_STRING_MAP_STRING_INT;
13453  hid_t item_type0;
13454  hsize_t shape01=shape[0];
13455  hid_t item_type1key;
13456  item_type1key=sha1_type_;
13457  hid_t item_type1val;
13458  hsize_t shape02=shape[2];
13459  hid_t item_type2key;
13460  item_type2key=CreateFLStrType(shape[3]);
13461  hid_t item_type2val;
13462  item_type2val=H5T_NATIVE_INT;
13463  hid_t item_type2valcompound;
13464  item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(int));
13465  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13466  H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
13467  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
13468  hid_t item_type1compound;
13469  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((shape[3]+sizeof(int))*shape[2]));
13470  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13471  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13472  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13473  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((shape[3]+sizeof(int))*shape[2]))*shape[0]);
13474  field_types[i]=item_type0;
13475  opened_types_.insert(item_type2valcompound);
13476  opened_types_.insert(item_type1val);
13477  opened_types_.insert(item_type1compound);
13478  opened_types_.insert(field_types[i]);
13479 
13480  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[3]>=1){
13482  hid_t item_type0;
13483  hsize_t shape01=shape[0];
13484  hid_t item_type1key;
13485  item_type1key=sha1_type_;
13486  hid_t item_type1val;
13487  hid_t item_type2key;
13488  item_type2key=sha1_type_;
13489  hid_t item_type2val;
13490  item_type2val=H5T_NATIVE_INT;
13491  hid_t item_type2valcompound;
13492  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13493  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13494  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13495  item_type1val=sha1_type_;
13496  if(vldts_.count(VL_MAP_STRING_INT)==0){
13497  vldts_[VL_MAP_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13498  opened_types_.insert(vldts_[VL_MAP_STRING_INT]);
13499 
13500  }
13501  hid_t item_type1compound;
13502  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13503  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13504  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13505  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13506  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
13507  field_types[i]=item_type0;
13508  opened_types_.insert(item_type2valcompound);
13509  opened_types_.insert(item_type1val);
13510  opened_types_.insert(item_type1compound);
13511  opened_types_.insert(field_types[i]);
13512 
13513  }else if(shape[0]>=1&&shape[1]<1&&shape[2]>=1&&shape[3]<1){
13515  hid_t item_type0;
13516  hsize_t shape01=shape[0];
13517  hid_t item_type1key;
13518  item_type1key=sha1_type_;
13519  hid_t item_type1val;
13520  hsize_t shape02=shape[2];
13521  hid_t item_type2key;
13522  item_type2key=sha1_type_;
13523  hid_t item_type2val;
13524  item_type2val=H5T_NATIVE_INT;
13525  hid_t item_type2valcompound;
13526  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13527  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13528  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13529  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
13530  hid_t item_type1compound;
13531  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]));
13532  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13533  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13534  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13535  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]))*shape[0]);
13536  field_types[i]=item_type0;
13537  opened_types_.insert(item_type2valcompound);
13538  opened_types_.insert(item_type1val);
13539  opened_types_.insert(item_type1compound);
13540  opened_types_.insert(field_types[i]);
13541 
13542  }else if(shape[0]>=1&&shape[1]<1&&shape[2]<1&&shape[3]<1){
13544  hid_t item_type0;
13545  hsize_t shape01=shape[0];
13546  hid_t item_type1key;
13547  item_type1key=sha1_type_;
13548  hid_t item_type1val;
13549  hid_t item_type2key;
13550  item_type2key=sha1_type_;
13551  hid_t item_type2val;
13552  item_type2val=H5T_NATIVE_INT;
13553  hid_t item_type2valcompound;
13554  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13555  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13556  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13557  item_type1val=sha1_type_;
13558  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13559  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13560  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13561 
13562  }
13563  hid_t item_type1compound;
13564  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13565  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13566  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13567  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13568  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
13569  field_types[i]=item_type0;
13570  opened_types_.insert(item_type2valcompound);
13571  opened_types_.insert(item_type1val);
13572  opened_types_.insert(item_type1compound);
13573  opened_types_.insert(field_types[i]);
13574 
13575  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[3]>=1){
13576  dbtypes[i]=VL_MAP_STRING_MAP_STRING_INT;
13577  hid_t item_type0;
13578  hid_t item_type1key;
13579  item_type1key=sha1_type_;
13580  hid_t item_type1val;
13581  hsize_t shape02=shape[2];
13582  hid_t item_type2key;
13583  item_type2key=sha1_type_;
13584  hid_t item_type2val;
13585  item_type2val=H5T_NATIVE_INT;
13586  hid_t item_type2valcompound;
13587  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13588  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13589  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13590  item_type1val=sha1_type_;
13591  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13592  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13593  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13594 
13595  }
13596  hid_t item_type1compound;
13597  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13598  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13599  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13600  item_type0=sha1_type_;
13601  if(vldts_.count(VL_MAP_STRING_MAP_STRING_INT)==0){
13602  vldts_[VL_MAP_STRING_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
13603  opened_types_.insert(vldts_[VL_MAP_STRING_MAP_STRING_INT]);
13604 
13605  }
13606  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13607  field_types[i]=sha1_type_;
13608 
13609  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[3]>=1){
13611  hid_t item_type0;
13612  hid_t item_type1key;
13613  item_type1key=sha1_type_;
13614  hid_t item_type1val;
13615  hsize_t shape02=shape[2];
13616  hid_t item_type2key;
13617  item_type2key=sha1_type_;
13618  hid_t item_type2val;
13619  item_type2val=H5T_NATIVE_INT;
13620  hid_t item_type2valcompound;
13621  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13622  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13623  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13624  item_type1val=sha1_type_;
13625  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13626  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13627  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13628 
13629  }
13630  hid_t item_type1compound;
13631  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13632  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13633  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13634  item_type0=sha1_type_;
13635  if(vldts_.count(VL_MAP_VL_STRING_MAP_STRING_INT)==0){
13636  vldts_[VL_MAP_VL_STRING_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
13637  opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_STRING_INT]);
13638 
13639  }
13640  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13641  field_types[i]=sha1_type_;
13642 
13643  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[3]>=1){
13645  hid_t item_type0;
13646  hid_t item_type1key;
13647  item_type1key=sha1_type_;
13648  hid_t item_type1val;
13649  hid_t item_type2key;
13650  item_type2key=sha1_type_;
13651  hid_t item_type2val;
13652  item_type2val=H5T_NATIVE_INT;
13653  hid_t item_type2valcompound;
13654  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13655  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13656  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13657  item_type1val=sha1_type_;
13658  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13659  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13660  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13661 
13662  }
13663  hid_t item_type1compound;
13664  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13665  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13666  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13667  item_type0=sha1_type_;
13668  if(vldts_.count(VL_MAP_STRING_VL_MAP_STRING_INT)==0){
13669  vldts_[VL_MAP_STRING_VL_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
13670  opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_STRING_INT]);
13671 
13672  }
13673  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13674  field_types[i]=sha1_type_;
13675 
13676  }else if(shape[0]<1&&shape[1]>=1&&shape[2]>=1&&shape[3]<1){
13678  hid_t item_type0;
13679  hid_t item_type1key;
13680  item_type1key=sha1_type_;
13681  hid_t item_type1val;
13682  hsize_t shape02=shape[2];
13683  hid_t item_type2key;
13684  item_type2key=sha1_type_;
13685  hid_t item_type2val;
13686  item_type2val=H5T_NATIVE_INT;
13687  hid_t item_type2valcompound;
13688  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13689  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13690  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13691  item_type1val=sha1_type_;
13692  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13693  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13694  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13695 
13696  }
13697  hid_t item_type1compound;
13698  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13699  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13700  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13701  item_type0=sha1_type_;
13702  if(vldts_.count(VL_MAP_STRING_MAP_VL_STRING_INT)==0){
13703  vldts_[VL_MAP_STRING_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
13704  opened_types_.insert(vldts_[VL_MAP_STRING_MAP_VL_STRING_INT]);
13705 
13706  }
13707  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13708  field_types[i]=sha1_type_;
13709 
13710  }else if(shape[0]<1&&shape[1]>=1&&shape[2]<1&&shape[3]<1){
13712  hid_t item_type0;
13713  hid_t item_type1key;
13714  item_type1key=sha1_type_;
13715  hid_t item_type1val;
13716  hid_t item_type2key;
13717  item_type2key=sha1_type_;
13718  hid_t item_type2val;
13719  item_type2val=H5T_NATIVE_INT;
13720  hid_t item_type2valcompound;
13721  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13722  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13723  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13724  item_type1val=sha1_type_;
13725  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13726  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13727  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13728 
13729  }
13730  hid_t item_type1compound;
13731  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13732  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13733  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13734  item_type0=sha1_type_;
13735  if(vldts_.count(VL_MAP_STRING_VL_MAP_VL_STRING_INT)==0){
13736  vldts_[VL_MAP_STRING_VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
13737  opened_types_.insert(vldts_[VL_MAP_STRING_VL_MAP_VL_STRING_INT]);
13738 
13739  }
13740  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13741  field_types[i]=sha1_type_;
13742 
13743  }else if(shape[0]<1&&shape[1]<1&&shape[2]>=1&&shape[3]<1){
13745  hid_t item_type0;
13746  hid_t item_type1key;
13747  item_type1key=sha1_type_;
13748  hid_t item_type1val;
13749  hsize_t shape02=shape[2];
13750  hid_t item_type2key;
13751  item_type2key=sha1_type_;
13752  hid_t item_type2val;
13753  item_type2val=H5T_NATIVE_INT;
13754  hid_t item_type2valcompound;
13755  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13756  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13757  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13758  item_type1val=sha1_type_;
13759  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13760  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13761  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13762 
13763  }
13764  hid_t item_type1compound;
13765  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13766  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13767  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13768  item_type0=sha1_type_;
13769  if(vldts_.count(VL_MAP_VL_STRING_MAP_VL_STRING_INT)==0){
13770  vldts_[VL_MAP_VL_STRING_MAP_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
13771  opened_types_.insert(vldts_[VL_MAP_VL_STRING_MAP_VL_STRING_INT]);
13772 
13773  }
13774  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13775  field_types[i]=sha1_type_;
13776 
13777  }else if(shape[0]<1&&shape[1]<1&&shape[2]<1&&shape[3]>=1){
13779  hid_t item_type0;
13780  hid_t item_type1key;
13781  item_type1key=sha1_type_;
13782  hid_t item_type1val;
13783  hid_t item_type2key;
13784  item_type2key=sha1_type_;
13785  hid_t item_type2val;
13786  item_type2val=H5T_NATIVE_INT;
13787  hid_t item_type2valcompound;
13788  item_type2valcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(int));
13789  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13790  H5Tinsert(item_type2valcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
13791  item_type1val=sha1_type_;
13792  if(vldts_.count(VL_MAP_VL_STRING_INT)==0){
13793  vldts_[VL_MAP_VL_STRING_INT]=H5Tvlen_create(item_type2valcompound);
13794  opened_types_.insert(vldts_[VL_MAP_VL_STRING_INT]);
13795 
13796  }
13797  hid_t item_type1compound;
13798  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
13799  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13800  H5Tinsert(item_type1compound, "val", 0+CYCLUS_SHA1_SIZE, item_type1val);
13801  item_type0=sha1_type_;
13802  if(vldts_.count(VL_MAP_VL_STRING_VL_MAP_STRING_INT)==0){
13803  vldts_[VL_MAP_VL_STRING_VL_MAP_STRING_INT]=H5Tvlen_create(item_type1compound);
13804  opened_types_.insert(vldts_[VL_MAP_VL_STRING_VL_MAP_STRING_INT]);
13805 
13806  }
13807  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13808  field_types[i]=sha1_type_;
13809 
13810  }else{
13811  dbtypes[i]=MAP_STRING_MAP_STRING_INT;
13812  hid_t item_type0;
13813  hsize_t shape01=shape[0];
13814  hid_t item_type1key;
13815  item_type1key=CreateFLStrType(shape[1]);
13816  hid_t item_type1val;
13817  hsize_t shape02=shape[2];
13818  hid_t item_type2key;
13819  item_type2key=CreateFLStrType(shape[3]);
13820  hid_t item_type2val;
13821  item_type2val=H5T_NATIVE_INT;
13822  hid_t item_type2valcompound;
13823  item_type2valcompound=H5Tcreate(H5T_COMPOUND, shape[3]+sizeof(int));
13824  H5Tinsert(item_type2valcompound, "key", 0, item_type2key);
13825  H5Tinsert(item_type2valcompound, "val", 0+shape[3], item_type2val);
13826  item_type1val=H5Tarray_create2(item_type2valcompound, 1, &shape02);
13827  hid_t item_type1compound;
13828  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((shape[3]+sizeof(int))*shape[2]));
13829  H5Tinsert(item_type1compound, "key", 0, item_type1key);
13830  H5Tinsert(item_type1compound, "val", 0+shape[1], item_type1val);
13831  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
13832  dst_sizes[i]=((shape[1]+((shape[3]+sizeof(int))*shape[2]))*shape[0]);
13833  field_types[i]=item_type0;
13834  opened_types_.insert(item_type2valcompound);
13835  opened_types_.insert(item_type1val);
13836  opened_types_.insert(item_type1compound);
13837  opened_types_.insert(field_types[i]);
13838 
13839  }
13840 
13841  }else if(valtype==typeid(std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>)){
13842  shape=shapes[i];
13843  if(shape.empty()||shape[0]<1&&shape[5]<1&&shape[6]<1){
13845  hid_t item_type0;
13846  hid_t item_type1elem;
13847  hid_t item_type2first;
13848  hid_t item_type3first;
13849  item_type3first=H5T_NATIVE_DOUBLE;
13850  hid_t item_type3second;
13851  item_type3second=H5T_NATIVE_DOUBLE;
13852  hid_t item_type3firstcompound;
13853  item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
13854  H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
13855  H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
13856  hid_t item_type2second;
13857  hid_t item_type3key;
13858  item_type3key=sha1_type_;
13859  hid_t item_type3val;
13860  item_type3val=H5T_NATIVE_DOUBLE;
13861  hid_t item_type3secondcompound;
13862  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
13863  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
13864  H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
13865  item_type2second=sha1_type_;
13866  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
13867  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
13868  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
13869 
13870  }
13871  hid_t item_type2elemcompound;
13872  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
13873  H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
13874  H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
13875  item_type0=sha1_type_;
13877  vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2elemcompound);
13878  opened_types_.insert(vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE]);
13879 
13880  }
13881  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
13882  field_types[i]=sha1_type_;
13883 
13884  }else if(shape[0]>=1&&shape[5]>=1&&shape[6]<1){
13886  hid_t item_type0;
13887  hsize_t shape01=shape[0];
13888  hid_t item_type1elem;
13889  hid_t item_type2first;
13890  hid_t item_type3first;
13891  item_type3first=H5T_NATIVE_DOUBLE;
13892  hid_t item_type3second;
13893  item_type3second=H5T_NATIVE_DOUBLE;
13894  hid_t item_type3firstcompound;
13895  item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
13896  H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
13897  H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
13898  hid_t item_type2second;
13899  hsize_t shape03=shape[5];
13900  hid_t item_type3key;
13901  item_type3key=sha1_type_;
13902  hid_t item_type3val;
13903  item_type3val=H5T_NATIVE_DOUBLE;
13904  hid_t item_type3secondcompound;
13905  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
13906  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
13907  H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
13908  item_type2second=H5Tarray_create2(item_type3secondcompound, 1, &shape03);
13909  hid_t item_type2elemcompound;
13910  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]));
13911  H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
13912  H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
13913  item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
13914  dst_sizes[i]=((((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]))))*shape[0]);
13915  field_types[i]=item_type0;
13916  opened_types_.insert(item_type3firstcompound);
13917  opened_types_.insert(item_type3secondcompound);
13918  opened_types_.insert(item_type2second);
13919  opened_types_.insert(item_type2elemcompound);
13920  opened_types_.insert(field_types[i]);
13921 
13922  }else if(shape[0]>=1&&shape[5]<1&&shape[6]>=1){
13924  hid_t item_type0;
13925  hsize_t shape01=shape[0];
13926  hid_t item_type1elem;
13927  hid_t item_type2first;
13928  hid_t item_type3first;
13929  item_type3first=H5T_NATIVE_DOUBLE;
13930  hid_t item_type3second;
13931  item_type3second=H5T_NATIVE_DOUBLE;
13932  hid_t item_type3firstcompound;
13933  item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
13934  H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
13935  H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
13936  hid_t item_type2second;
13937  hid_t item_type3key;
13938  item_type3key=sha1_type_;
13939  hid_t item_type3val;
13940  item_type3val=H5T_NATIVE_DOUBLE;
13941  hid_t item_type3secondcompound;
13942  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
13943  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
13944  H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
13945  item_type2second=sha1_type_;
13946  if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
13947  vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
13948  opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
13949 
13950  }
13951  hid_t item_type2elemcompound;
13952  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
13953  H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
13954  H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
13955  item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
13956  dst_sizes[i]=((((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE))))*shape[0]);
13957  field_types[i]=item_type0;
13958  opened_types_.insert(item_type3firstcompound);
13959  opened_types_.insert(item_type3secondcompound);
13960  opened_types_.insert(item_type2second);
13961  opened_types_.insert(item_type2elemcompound);
13962  opened_types_.insert(field_types[i]);
13963 
13964  }else if(shape[0]>=1&&shape[5]<1&&shape[6]<1){
13966  hid_t item_type0;
13967  hsize_t shape01=shape[0];
13968  hid_t item_type1elem;
13969  hid_t item_type2first;
13970  hid_t item_type3first;
13971  item_type3first=H5T_NATIVE_DOUBLE;
13972  hid_t item_type3second;
13973  item_type3second=H5T_NATIVE_DOUBLE;
13974  hid_t item_type3firstcompound;
13975  item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
13976  H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
13977  H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
13978  hid_t item_type2second;
13979  hid_t item_type3key;
13980  item_type3key=sha1_type_;
13981  hid_t item_type3val;
13982  item_type3val=H5T_NATIVE_DOUBLE;
13983  hid_t item_type3secondcompound;
13984  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
13985  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
13986  H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
13987  item_type2second=sha1_type_;
13988  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
13989  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
13990  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
13991 
13992  }
13993  hid_t item_type2elemcompound;
13994  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
13995  H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
13996  H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
13997  item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
13998  dst_sizes[i]=((((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE))))*shape[0]);
13999  field_types[i]=item_type0;
14000  opened_types_.insert(item_type3firstcompound);
14001  opened_types_.insert(item_type3secondcompound);
14002  opened_types_.insert(item_type2second);
14003  opened_types_.insert(item_type2elemcompound);
14004  opened_types_.insert(field_types[i]);
14005 
14006  }else if(shape[0]<1&&shape[5]>=1&&shape[6]>=1){
14008  hid_t item_type0;
14009  hid_t item_type1elem;
14010  hid_t item_type2first;
14011  hid_t item_type3first;
14012  item_type3first=H5T_NATIVE_DOUBLE;
14013  hid_t item_type3second;
14014  item_type3second=H5T_NATIVE_DOUBLE;
14015  hid_t item_type3firstcompound;
14016  item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14017  H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
14018  H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
14019  hid_t item_type2second;
14020  hsize_t shape03=shape[5];
14021  hid_t item_type3key;
14022  item_type3key=sha1_type_;
14023  hid_t item_type3val;
14024  item_type3val=H5T_NATIVE_DOUBLE;
14025  hid_t item_type3secondcompound;
14026  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14027  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
14028  H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
14029  item_type2second=sha1_type_;
14030  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
14031  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
14032  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
14033 
14034  }
14035  hid_t item_type2elemcompound;
14036  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14037  H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
14038  H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
14039  item_type0=sha1_type_;
14041  vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2elemcompound);
14042  opened_types_.insert(vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE]);
14043 
14044  }
14045  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14046  field_types[i]=sha1_type_;
14047 
14048  }else if(shape[0]<1&&shape[5]>=1&&shape[6]<1){
14050  hid_t item_type0;
14051  hid_t item_type1elem;
14052  hid_t item_type2first;
14053  hid_t item_type3first;
14054  item_type3first=H5T_NATIVE_DOUBLE;
14055  hid_t item_type3second;
14056  item_type3second=H5T_NATIVE_DOUBLE;
14057  hid_t item_type3firstcompound;
14058  item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14059  H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
14060  H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
14061  hid_t item_type2second;
14062  hsize_t shape03=shape[5];
14063  hid_t item_type3key;
14064  item_type3key=sha1_type_;
14065  hid_t item_type3val;
14066  item_type3val=H5T_NATIVE_DOUBLE;
14067  hid_t item_type3secondcompound;
14068  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14069  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
14070  H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
14071  item_type2second=sha1_type_;
14072  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
14073  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
14074  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
14075 
14076  }
14077  hid_t item_type2elemcompound;
14078  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14079  H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
14080  H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
14081  item_type0=sha1_type_;
14083  vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2elemcompound);
14084  opened_types_.insert(vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE]);
14085 
14086  }
14087  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14088  field_types[i]=sha1_type_;
14089 
14090  }else if(shape[0]<1&&shape[5]<1&&shape[6]>=1){
14092  hid_t item_type0;
14093  hid_t item_type1elem;
14094  hid_t item_type2first;
14095  hid_t item_type3first;
14096  item_type3first=H5T_NATIVE_DOUBLE;
14097  hid_t item_type3second;
14098  item_type3second=H5T_NATIVE_DOUBLE;
14099  hid_t item_type3firstcompound;
14100  item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14101  H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
14102  H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
14103  hid_t item_type2second;
14104  hid_t item_type3key;
14105  item_type3key=sha1_type_;
14106  hid_t item_type3val;
14107  item_type3val=H5T_NATIVE_DOUBLE;
14108  hid_t item_type3secondcompound;
14109  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14110  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
14111  H5Tinsert(item_type3secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type3val);
14112  item_type2second=sha1_type_;
14113  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
14114  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type3secondcompound);
14115  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
14116 
14117  }
14118  hid_t item_type2elemcompound;
14119  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14120  H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
14121  H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
14122  item_type0=sha1_type_;
14124  vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2elemcompound);
14125  opened_types_.insert(vldts_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE]);
14126 
14127  }
14128  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14129  field_types[i]=sha1_type_;
14130 
14131  }else{
14133  hid_t item_type0;
14134  hsize_t shape01=shape[0];
14135  hid_t item_type1elem;
14136  hid_t item_type2first;
14137  hid_t item_type3first;
14138  item_type3first=H5T_NATIVE_DOUBLE;
14139  hid_t item_type3second;
14140  item_type3second=H5T_NATIVE_DOUBLE;
14141  hid_t item_type3firstcompound;
14142  item_type3firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14143  H5Tinsert(item_type3firstcompound, "first", 0, item_type3first);
14144  H5Tinsert(item_type3firstcompound, "second", 0+sizeof(double), item_type3second);
14145  hid_t item_type2second;
14146  hsize_t shape03=shape[5];
14147  hid_t item_type3key;
14148  item_type3key=CreateFLStrType(shape[6]);
14149  hid_t item_type3val;
14150  item_type3val=H5T_NATIVE_DOUBLE;
14151  hid_t item_type3secondcompound;
14152  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, shape[6]+sizeof(double));
14153  H5Tinsert(item_type3secondcompound, "key", 0, item_type3key);
14154  H5Tinsert(item_type3secondcompound, "val", 0+shape[6], item_type3val);
14155  item_type2second=H5Tarray_create2(item_type3secondcompound, 1, &shape03);
14156  hid_t item_type2elemcompound;
14157  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5]));
14158  H5Tinsert(item_type2elemcompound, "first", 0, item_type3firstcompound);
14159  H5Tinsert(item_type2elemcompound, "second", 0+((sizeof(double)+sizeof(double))), item_type2second);
14160  item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14161  dst_sizes[i]=((((((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5]))))*shape[0]);
14162  field_types[i]=item_type0;
14163  opened_types_.insert(item_type3firstcompound);
14164  opened_types_.insert(item_type3secondcompound);
14165  opened_types_.insert(item_type2second);
14166  opened_types_.insert(item_type2elemcompound);
14167  opened_types_.insert(field_types[i]);
14168 
14169  }
14170 
14171  }else if(valtype==typeid(std::pair<int, std::pair<std::string, std::string>>)){
14172  shape=shapes[i];
14173  if(shape.empty()||shape[3]<1&&shape[4]<1){
14175  hid_t item_type0;
14176  hid_t item_type1first;
14177  item_type1first=H5T_NATIVE_INT;
14178  hid_t item_type1second;
14179  hid_t item_type2first;
14180  item_type2first=sha1_type_;
14181  hid_t item_type2second;
14182  item_type2second=sha1_type_;
14183  hid_t item_type2secondcompound;
14184  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14185  H5Tinsert(item_type2secondcompound, "first", 0, item_type2first);
14186  H5Tinsert(item_type2secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14187  hid_t item_type1compound;
14188  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14189  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14190  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type2secondcompound);
14191  dst_sizes[i]=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
14192  field_types[i]=item_type1compound;
14193  opened_types_.insert(item_type2secondcompound);
14194  opened_types_.insert(field_types[i]);
14195 
14196  }else if(shape[3]<1&&shape[4]>=1){
14197  dbtypes[i]=PAIR_INT_PAIR_VL_STRING_STRING;
14198  hid_t item_type0;
14199  hid_t item_type1first;
14200  item_type1first=H5T_NATIVE_INT;
14201  hid_t item_type1second;
14202  hid_t item_type2first;
14203  item_type2first=sha1_type_;
14204  hid_t item_type2second;
14205  item_type2second=CreateFLStrType(shape[4]);
14206  hid_t item_type2secondcompound;
14207  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[4]);
14208  H5Tinsert(item_type2secondcompound, "first", 0, item_type2first);
14209  H5Tinsert(item_type2secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14210  hid_t item_type1compound;
14211  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+shape[4])));
14212  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14213  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type2secondcompound);
14214  dst_sizes[i]=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[4]))));
14215  field_types[i]=item_type1compound;
14216  opened_types_.insert(item_type2secondcompound);
14217  opened_types_.insert(field_types[i]);
14218 
14219  }else if(shape[3]>=1&&shape[4]<1){
14220  dbtypes[i]=PAIR_INT_PAIR_STRING_VL_STRING;
14221  hid_t item_type0;
14222  hid_t item_type1first;
14223  item_type1first=H5T_NATIVE_INT;
14224  hid_t item_type1second;
14225  hid_t item_type2first;
14226  item_type2first=CreateFLStrType(shape[3]);
14227  hid_t item_type2second;
14228  item_type2second=sha1_type_;
14229  hid_t item_type2secondcompound;
14230  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, shape[3]+CYCLUS_SHA1_SIZE);
14231  H5Tinsert(item_type2secondcompound, "first", 0, item_type2first);
14232  H5Tinsert(item_type2secondcompound, "second", 0+shape[3], item_type2second);
14233  hid_t item_type1compound;
14234  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[3]+CYCLUS_SHA1_SIZE)));
14235  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14236  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type2secondcompound);
14237  dst_sizes[i]=((sizeof(int)+((shape[3]+CYCLUS_SHA1_SIZE))));
14238  field_types[i]=item_type1compound;
14239  opened_types_.insert(item_type2secondcompound);
14240  opened_types_.insert(field_types[i]);
14241 
14242  }else{
14243  dbtypes[i]=PAIR_INT_PAIR_STRING_STRING;
14244  hid_t item_type0;
14245  hid_t item_type1first;
14246  item_type1first=H5T_NATIVE_INT;
14247  hid_t item_type1second;
14248  hid_t item_type2first;
14249  item_type2first=CreateFLStrType(shape[3]);
14250  hid_t item_type2second;
14251  item_type2second=CreateFLStrType(shape[4]);
14252  hid_t item_type2secondcompound;
14253  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, shape[3]+shape[4]);
14254  H5Tinsert(item_type2secondcompound, "first", 0, item_type2first);
14255  H5Tinsert(item_type2secondcompound, "second", 0+shape[3], item_type2second);
14256  hid_t item_type1compound;
14257  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[3]+shape[4])));
14258  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14259  H5Tinsert(item_type1compound, "second", 0+sizeof(int), item_type2secondcompound);
14260  dst_sizes[i]=((sizeof(int)+((shape[3]+shape[4]))));
14261  field_types[i]=item_type1compound;
14262  opened_types_.insert(item_type2secondcompound);
14263  opened_types_.insert(field_types[i]);
14264 
14265  }
14266 
14267  }else if(valtype==typeid(std::pair<double, double>)){
14268  shape=shapes[i];
14269  dbtypes[i]=PAIR_DOUBLE_DOUBLE;
14270  hid_t item_type0;
14271  hid_t item_type1first;
14272  item_type1first=H5T_NATIVE_DOUBLE;
14273  hid_t item_type1second;
14274  item_type1second=H5T_NATIVE_DOUBLE;
14275  hid_t item_type1compound;
14276  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14277  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14278  H5Tinsert(item_type1compound, "second", 0+sizeof(double), item_type1second);
14279  dst_sizes[i]=((sizeof(double)+sizeof(double)));
14280  field_types[i]=item_type1compound;
14281  opened_types_.insert(field_types[i]);
14282 
14283  }else if(valtype==typeid(std::pair<std::pair<double, double>, std::map<std::string, double>>)){
14284  shape=shapes[i];
14285  if(shape.empty()||shape[4]<1&&shape[5]<1){
14287  hid_t item_type0;
14288  hid_t item_type1first;
14289  hid_t item_type2first;
14290  item_type2first=H5T_NATIVE_DOUBLE;
14291  hid_t item_type2second;
14292  item_type2second=H5T_NATIVE_DOUBLE;
14293  hid_t item_type2firstcompound;
14294  item_type2firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14295  H5Tinsert(item_type2firstcompound, "first", 0, item_type2first);
14296  H5Tinsert(item_type2firstcompound, "second", 0+sizeof(double), item_type2second);
14297  hid_t item_type1second;
14298  hid_t item_type2key;
14299  item_type2key=sha1_type_;
14300  hid_t item_type2val;
14301  item_type2val=H5T_NATIVE_DOUBLE;
14302  hid_t item_type2secondcompound;
14303  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14304  H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14305  H5Tinsert(item_type2secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
14306  item_type1second=sha1_type_;
14307  if(vldts_.count(VL_MAP_VL_STRING_DOUBLE)==0){
14308  vldts_[VL_MAP_VL_STRING_DOUBLE]=H5Tvlen_create(item_type2secondcompound);
14309  opened_types_.insert(vldts_[VL_MAP_VL_STRING_DOUBLE]);
14310 
14311  }
14312  hid_t item_type1compound;
14313  item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14314  H5Tinsert(item_type1compound, "first", 0, item_type2firstcompound);
14315  H5Tinsert(item_type1compound, "second", 0+((sizeof(double)+sizeof(double))), item_type1second);
14316  dst_sizes[i]=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
14317  field_types[i]=item_type1compound;
14318  opened_types_.insert(item_type2firstcompound);
14319  opened_types_.insert(item_type2secondcompound);
14320  opened_types_.insert(item_type1second);
14321  opened_types_.insert(field_types[i]);
14322 
14323  }else if(shape[4]>=1&&shape[5]<1){
14325  hid_t item_type0;
14326  hid_t item_type1first;
14327  hid_t item_type2first;
14328  item_type2first=H5T_NATIVE_DOUBLE;
14329  hid_t item_type2second;
14330  item_type2second=H5T_NATIVE_DOUBLE;
14331  hid_t item_type2firstcompound;
14332  item_type2firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14333  H5Tinsert(item_type2firstcompound, "first", 0, item_type2first);
14334  H5Tinsert(item_type2firstcompound, "second", 0+sizeof(double), item_type2second);
14335  hid_t item_type1second;
14336  hsize_t shape02=shape[4];
14337  hid_t item_type2key;
14338  item_type2key=sha1_type_;
14339  hid_t item_type2val;
14340  item_type2val=H5T_NATIVE_DOUBLE;
14341  hid_t item_type2secondcompound;
14342  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14343  H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14344  H5Tinsert(item_type2secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
14345  item_type1second=H5Tarray_create2(item_type2secondcompound, 1, &shape02);
14346  hid_t item_type1compound;
14347  item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[4]));
14348  H5Tinsert(item_type1compound, "first", 0, item_type2firstcompound);
14349  H5Tinsert(item_type1compound, "second", 0+((sizeof(double)+sizeof(double))), item_type1second);
14350  dst_sizes[i]=((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[4])));
14351  field_types[i]=item_type1compound;
14352  opened_types_.insert(item_type2firstcompound);
14353  opened_types_.insert(item_type2secondcompound);
14354  opened_types_.insert(item_type1second);
14355  opened_types_.insert(field_types[i]);
14356 
14357  }else if(shape[4]<1&&shape[5]>=1){
14359  hid_t item_type0;
14360  hid_t item_type1first;
14361  hid_t item_type2first;
14362  item_type2first=H5T_NATIVE_DOUBLE;
14363  hid_t item_type2second;
14364  item_type2second=H5T_NATIVE_DOUBLE;
14365  hid_t item_type2firstcompound;
14366  item_type2firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14367  H5Tinsert(item_type2firstcompound, "first", 0, item_type2first);
14368  H5Tinsert(item_type2firstcompound, "second", 0+sizeof(double), item_type2second);
14369  hid_t item_type1second;
14370  hid_t item_type2key;
14371  item_type2key=sha1_type_;
14372  hid_t item_type2val;
14373  item_type2val=H5T_NATIVE_DOUBLE;
14374  hid_t item_type2secondcompound;
14375  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+sizeof(double));
14376  H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14377  H5Tinsert(item_type2secondcompound, "val", 0+CYCLUS_SHA1_SIZE, item_type2val);
14378  item_type1second=sha1_type_;
14379  if(vldts_.count(VL_MAP_STRING_DOUBLE)==0){
14380  vldts_[VL_MAP_STRING_DOUBLE]=H5Tvlen_create(item_type2secondcompound);
14381  opened_types_.insert(vldts_[VL_MAP_STRING_DOUBLE]);
14382 
14383  }
14384  hid_t item_type1compound;
14385  item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE));
14386  H5Tinsert(item_type1compound, "first", 0, item_type2firstcompound);
14387  H5Tinsert(item_type1compound, "second", 0+((sizeof(double)+sizeof(double))), item_type1second);
14388  dst_sizes[i]=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
14389  field_types[i]=item_type1compound;
14390  opened_types_.insert(item_type2firstcompound);
14391  opened_types_.insert(item_type2secondcompound);
14392  opened_types_.insert(item_type1second);
14393  opened_types_.insert(field_types[i]);
14394 
14395  }else{
14397  hid_t item_type0;
14398  hid_t item_type1first;
14399  hid_t item_type2first;
14400  item_type2first=H5T_NATIVE_DOUBLE;
14401  hid_t item_type2second;
14402  item_type2second=H5T_NATIVE_DOUBLE;
14403  hid_t item_type2firstcompound;
14404  item_type2firstcompound=H5Tcreate(H5T_COMPOUND, sizeof(double)+sizeof(double));
14405  H5Tinsert(item_type2firstcompound, "first", 0, item_type2first);
14406  H5Tinsert(item_type2firstcompound, "second", 0+sizeof(double), item_type2second);
14407  hid_t item_type1second;
14408  hsize_t shape02=shape[4];
14409  hid_t item_type2key;
14410  item_type2key=CreateFLStrType(shape[5]);
14411  hid_t item_type2val;
14412  item_type2val=H5T_NATIVE_DOUBLE;
14413  hid_t item_type2secondcompound;
14414  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, shape[5]+sizeof(double));
14415  H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14416  H5Tinsert(item_type2secondcompound, "val", 0+shape[5], item_type2val);
14417  item_type1second=H5Tarray_create2(item_type2secondcompound, 1, &shape02);
14418  hid_t item_type1compound;
14419  item_type1compound=H5Tcreate(H5T_COMPOUND, ((sizeof(double)+sizeof(double)))+((shape[5]+sizeof(double))*shape[4]));
14420  H5Tinsert(item_type1compound, "first", 0, item_type2firstcompound);
14421  H5Tinsert(item_type1compound, "second", 0+((sizeof(double)+sizeof(double))), item_type1second);
14422  dst_sizes[i]=((((sizeof(double)+sizeof(double)))+((shape[5]+sizeof(double))*shape[4])));
14423  field_types[i]=item_type1compound;
14424  opened_types_.insert(item_type2firstcompound);
14425  opened_types_.insert(item_type2secondcompound);
14426  opened_types_.insert(item_type1second);
14427  opened_types_.insert(field_types[i]);
14428 
14429  }
14430 
14431  }else if(valtype==typeid(std::pair<double, std::map<int, double>>)){
14432  shape=shapes[i];
14433  if(shape.empty()||shape[2]<1){
14434  dbtypes[i]=PAIR_DOUBLE_VL_MAP_INT_DOUBLE;
14435  hid_t item_type0;
14436  hid_t item_type1first;
14437  item_type1first=H5T_NATIVE_DOUBLE;
14438  hid_t item_type1second;
14439  hid_t item_type2key;
14440  item_type2key=H5T_NATIVE_INT;
14441  hid_t item_type2val;
14442  item_type2val=H5T_NATIVE_DOUBLE;
14443  hid_t item_type2secondcompound;
14444  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
14445  H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14446  H5Tinsert(item_type2secondcompound, "val", 0+sizeof(int), item_type2val);
14447  item_type1second=sha1_type_;
14448  if(vldts_.count(VL_MAP_INT_DOUBLE)==0){
14449  vldts_[VL_MAP_INT_DOUBLE]=H5Tvlen_create(item_type2secondcompound);
14450  opened_types_.insert(vldts_[VL_MAP_INT_DOUBLE]);
14451 
14452  }
14453  hid_t item_type1compound;
14454  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(double)+(CYCLUS_SHA1_SIZE));
14455  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14456  H5Tinsert(item_type1compound, "second", 0+sizeof(double), item_type1second);
14457  dst_sizes[i]=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
14458  field_types[i]=item_type1compound;
14459  opened_types_.insert(item_type2secondcompound);
14460  opened_types_.insert(item_type1second);
14461  opened_types_.insert(field_types[i]);
14462 
14463  }else{
14464  dbtypes[i]=PAIR_DOUBLE_MAP_INT_DOUBLE;
14465  hid_t item_type0;
14466  hid_t item_type1first;
14467  item_type1first=H5T_NATIVE_DOUBLE;
14468  hid_t item_type1second;
14469  hsize_t shape02=shape[2];
14470  hid_t item_type2key;
14471  item_type2key=H5T_NATIVE_INT;
14472  hid_t item_type2val;
14473  item_type2val=H5T_NATIVE_DOUBLE;
14474  hid_t item_type2secondcompound;
14475  item_type2secondcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+sizeof(double));
14476  H5Tinsert(item_type2secondcompound, "key", 0, item_type2key);
14477  H5Tinsert(item_type2secondcompound, "val", 0+sizeof(int), item_type2val);
14478  item_type1second=H5Tarray_create2(item_type2secondcompound, 1, &shape02);
14479  hid_t item_type1compound;
14480  item_type1compound=H5Tcreate(H5T_COMPOUND, sizeof(double)+((sizeof(int)+sizeof(double))*shape[2]));
14481  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14482  H5Tinsert(item_type1compound, "second", 0+sizeof(double), item_type1second);
14483  dst_sizes[i]=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[2])));
14484  field_types[i]=item_type1compound;
14485  opened_types_.insert(item_type2secondcompound);
14486  opened_types_.insert(item_type1second);
14487  opened_types_.insert(field_types[i]);
14488 
14489  }
14490 
14491  }else if(valtype==typeid(std::vector<std::pair<int, std::pair<std::string, std::string>>>)){
14492  shape=shapes[i];
14493  if(shape.empty()||shape[0]<1&&shape[4]<1&&shape[5]<1){
14495  hid_t item_type0;
14496  hid_t item_type1elem;
14497  hid_t item_type2first;
14498  item_type2first=H5T_NATIVE_INT;
14499  hid_t item_type2second;
14500  hid_t item_type3first;
14501  item_type3first=sha1_type_;
14502  hid_t item_type3second;
14503  item_type3second=sha1_type_;
14504  hid_t item_type3secondcompound;
14505  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14506  H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14507  H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14508  hid_t item_type2elemcompound;
14509  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14510  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14511  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14512  item_type0=sha1_type_;
14513  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING)==0){
14514  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]=H5Tvlen_create(item_type2elemcompound);
14515  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING]);
14516 
14517  }
14518  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14519  field_types[i]=sha1_type_;
14520 
14521  }else if(shape[0]>=1&&shape[4]<1&&shape[5]>=1){
14523  hid_t item_type0;
14524  hsize_t shape01=shape[0];
14525  hid_t item_type1elem;
14526  hid_t item_type2first;
14527  item_type2first=H5T_NATIVE_INT;
14528  hid_t item_type2second;
14529  hid_t item_type3first;
14530  item_type3first=sha1_type_;
14531  hid_t item_type3second;
14532  item_type3second=CreateFLStrType(shape[5]);
14533  hid_t item_type3secondcompound;
14534  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[5]);
14535  H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14536  H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14537  hid_t item_type2elemcompound;
14538  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5])));
14539  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14540  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14541  item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14542  dst_sizes[i]=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5])))))*shape[0]);
14543  field_types[i]=item_type0;
14544  opened_types_.insert(item_type3secondcompound);
14545  opened_types_.insert(item_type2elemcompound);
14546  opened_types_.insert(field_types[i]);
14547 
14548  }else if(shape[0]>=1&&shape[4]>=1&&shape[5]<1){
14550  hid_t item_type0;
14551  hsize_t shape01=shape[0];
14552  hid_t item_type1elem;
14553  hid_t item_type2first;
14554  item_type2first=H5T_NATIVE_INT;
14555  hid_t item_type2second;
14556  hid_t item_type3first;
14557  item_type3first=CreateFLStrType(shape[4]);
14558  hid_t item_type3second;
14559  item_type3second=sha1_type_;
14560  hid_t item_type3secondcompound;
14561  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, shape[4]+CYCLUS_SHA1_SIZE);
14562  H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14563  H5Tinsert(item_type3secondcompound, "second", 0+shape[4], item_type3second);
14564  hid_t item_type2elemcompound;
14565  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE)));
14566  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14567  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14568  item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14569  dst_sizes[i]=((((sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE)))))*shape[0]);
14570  field_types[i]=item_type0;
14571  opened_types_.insert(item_type3secondcompound);
14572  opened_types_.insert(item_type2elemcompound);
14573  opened_types_.insert(field_types[i]);
14574 
14575  }else if(shape[0]>=1&&shape[4]<1&&shape[5]<1){
14577  hid_t item_type0;
14578  hsize_t shape01=shape[0];
14579  hid_t item_type1elem;
14580  hid_t item_type2first;
14581  item_type2first=H5T_NATIVE_INT;
14582  hid_t item_type2second;
14583  hid_t item_type3first;
14584  item_type3first=sha1_type_;
14585  hid_t item_type3second;
14586  item_type3second=sha1_type_;
14587  hid_t item_type3secondcompound;
14588  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14589  H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14590  H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14591  hid_t item_type2elemcompound;
14592  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14593  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14594  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14595  item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14596  dst_sizes[i]=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[0]);
14597  field_types[i]=item_type0;
14598  opened_types_.insert(item_type3secondcompound);
14599  opened_types_.insert(item_type2elemcompound);
14600  opened_types_.insert(field_types[i]);
14601 
14602  }else if(shape[0]<1&&shape[4]>=1&&shape[5]>=1){
14604  hid_t item_type0;
14605  hid_t item_type1elem;
14606  hid_t item_type2first;
14607  item_type2first=H5T_NATIVE_INT;
14608  hid_t item_type2second;
14609  hid_t item_type3first;
14610  item_type3first=sha1_type_;
14611  hid_t item_type3second;
14612  item_type3second=sha1_type_;
14613  hid_t item_type3secondcompound;
14614  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14615  H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14616  H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14617  hid_t item_type2elemcompound;
14618  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14619  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14620  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14621  item_type0=sha1_type_;
14622  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING)==0){
14623  vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]=H5Tvlen_create(item_type2elemcompound);
14624  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING]);
14625 
14626  }
14627  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14628  field_types[i]=sha1_type_;
14629 
14630  }else if(shape[0]<1&&shape[4]<1&&shape[5]>=1){
14632  hid_t item_type0;
14633  hid_t item_type1elem;
14634  hid_t item_type2first;
14635  item_type2first=H5T_NATIVE_INT;
14636  hid_t item_type2second;
14637  hid_t item_type3first;
14638  item_type3first=sha1_type_;
14639  hid_t item_type3second;
14640  item_type3second=sha1_type_;
14641  hid_t item_type3secondcompound;
14642  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14643  H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14644  H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14645  hid_t item_type2elemcompound;
14646  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14647  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14648  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14649  item_type0=sha1_type_;
14650  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING)==0){
14651  vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]=H5Tvlen_create(item_type2elemcompound);
14652  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING]);
14653 
14654  }
14655  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14656  field_types[i]=sha1_type_;
14657 
14658  }else if(shape[0]<1&&shape[4]>=1&&shape[5]<1){
14660  hid_t item_type0;
14661  hid_t item_type1elem;
14662  hid_t item_type2first;
14663  item_type2first=H5T_NATIVE_INT;
14664  hid_t item_type2second;
14665  hid_t item_type3first;
14666  item_type3first=sha1_type_;
14667  hid_t item_type3second;
14668  item_type3second=sha1_type_;
14669  hid_t item_type3secondcompound;
14670  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14671  H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14672  H5Tinsert(item_type3secondcompound, "second", 0+CYCLUS_SHA1_SIZE, item_type3second);
14673  hid_t item_type2elemcompound;
14674  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)));
14675  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14676  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14677  item_type0=sha1_type_;
14678  if(vldts_.count(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING)==0){
14679  vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]=H5Tvlen_create(item_type2elemcompound);
14680  opened_types_.insert(vldts_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING]);
14681 
14682  }
14683  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14684  field_types[i]=sha1_type_;
14685 
14686  }else{
14688  hid_t item_type0;
14689  hsize_t shape01=shape[0];
14690  hid_t item_type1elem;
14691  hid_t item_type2first;
14692  item_type2first=H5T_NATIVE_INT;
14693  hid_t item_type2second;
14694  hid_t item_type3first;
14695  item_type3first=CreateFLStrType(shape[4]);
14696  hid_t item_type3second;
14697  item_type3second=CreateFLStrType(shape[5]);
14698  hid_t item_type3secondcompound;
14699  item_type3secondcompound=H5Tcreate(H5T_COMPOUND, shape[4]+shape[5]);
14700  H5Tinsert(item_type3secondcompound, "first", 0, item_type3first);
14701  H5Tinsert(item_type3secondcompound, "second", 0+shape[4], item_type3second);
14702  hid_t item_type2elemcompound;
14703  item_type2elemcompound=H5Tcreate(H5T_COMPOUND, sizeof(int)+((shape[4]+shape[5])));
14704  H5Tinsert(item_type2elemcompound, "first", 0, item_type2first);
14705  H5Tinsert(item_type2elemcompound, "second", 0+sizeof(int), item_type3secondcompound);
14706  item_type0=H5Tarray_create2(item_type2elemcompound, 1, &shape01);
14707  dst_sizes[i]=((((sizeof(int)+((shape[4]+shape[5])))))*shape[0]);
14708  field_types[i]=item_type0;
14709  opened_types_.insert(item_type3secondcompound);
14710  opened_types_.insert(item_type2elemcompound);
14711  opened_types_.insert(field_types[i]);
14712 
14713  }
14714 
14715  }else if(valtype==typeid(std::pair<std::string, std::vector<double>>)){
14716  shape=shapes[i];
14717  if(shape.empty()||shape[1]<1&&shape[2]<1){
14719  hid_t item_type0;
14720  hid_t item_type1first;
14721  item_type1first=sha1_type_;
14722  hid_t item_type1second;
14723  hid_t item_type2elem;
14724  item_type2elem=H5T_NATIVE_DOUBLE;
14725  item_type1second=sha1_type_;
14726  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
14727  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
14728  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
14729 
14730  }
14731  hid_t item_type1compound;
14732  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE));
14733  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14734  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
14735  dst_sizes[i]=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
14736  field_types[i]=item_type1compound;
14737  opened_types_.insert(item_type1second);
14738  opened_types_.insert(field_types[i]);
14739 
14740  }else if(shape[1]<1&&shape[2]>=1){
14741  dbtypes[i]=PAIR_VL_STRING_VECTOR_DOUBLE;
14742  hid_t item_type0;
14743  hid_t item_type1first;
14744  item_type1first=sha1_type_;
14745  hid_t item_type1second;
14746  hsize_t shape02=shape[2];
14747  hid_t item_type2elem;
14748  item_type2elem=H5T_NATIVE_DOUBLE;
14749  item_type1second=H5Tarray_create2(item_type2elem, 1, &shape02);
14750  hid_t item_type1compound;
14751  item_type1compound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2]));
14752  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14753  H5Tinsert(item_type1compound, "second", 0+CYCLUS_SHA1_SIZE, item_type1second);
14754  dst_sizes[i]=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2])));
14755  field_types[i]=item_type1compound;
14756  opened_types_.insert(item_type1second);
14757  opened_types_.insert(field_types[i]);
14758 
14759  }else if(shape[1]>=1&&shape[2]<1){
14760  dbtypes[i]=PAIR_STRING_VL_VECTOR_DOUBLE;
14761  hid_t item_type0;
14762  hid_t item_type1first;
14763  item_type1first=CreateFLStrType(shape[1]);
14764  hid_t item_type1second;
14765  hid_t item_type2elem;
14766  item_type2elem=H5T_NATIVE_DOUBLE;
14767  item_type1second=sha1_type_;
14768  if(vldts_.count(VL_VECTOR_DOUBLE)==0){
14769  vldts_[VL_VECTOR_DOUBLE]=H5Tvlen_create(item_type2elem);
14770  opened_types_.insert(vldts_[VL_VECTOR_DOUBLE]);
14771 
14772  }
14773  hid_t item_type1compound;
14774  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+(CYCLUS_SHA1_SIZE));
14775  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14776  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
14777  dst_sizes[i]=((shape[1]+(CYCLUS_SHA1_SIZE)));
14778  field_types[i]=item_type1compound;
14779  opened_types_.insert(item_type1second);
14780  opened_types_.insert(field_types[i]);
14781 
14782  }else{
14783  dbtypes[i]=PAIR_STRING_VECTOR_DOUBLE;
14784  hid_t item_type0;
14785  hid_t item_type1first;
14786  item_type1first=CreateFLStrType(shape[1]);
14787  hid_t item_type1second;
14788  hsize_t shape02=shape[2];
14789  hid_t item_type2elem;
14790  item_type2elem=H5T_NATIVE_DOUBLE;
14791  item_type1second=H5Tarray_create2(item_type2elem, 1, &shape02);
14792  hid_t item_type1compound;
14793  item_type1compound=H5Tcreate(H5T_COMPOUND, shape[1]+((sizeof(double))*shape[2]));
14794  H5Tinsert(item_type1compound, "first", 0, item_type1first);
14795  H5Tinsert(item_type1compound, "second", 0+shape[1], item_type1second);
14796  dst_sizes[i]=((shape[1]+((sizeof(double))*shape[2])));
14797  field_types[i]=item_type1compound;
14798  opened_types_.insert(item_type1second);
14799  opened_types_.insert(field_types[i]);
14800 
14801  }
14802 
14803  }else if(valtype==typeid(std::map<std::pair<std::string, std::string>, int>)){
14804  shape=shapes[i];
14805  if(shape.empty()||shape[0]<1&&shape[2]<1&&shape[3]<1){
14807  hid_t item_type0;
14808  hid_t item_type1key;
14809  hid_t item_type2first;
14810  item_type2first=sha1_type_;
14811  hid_t item_type2second;
14812  item_type2second=sha1_type_;
14813  hid_t item_type2keycompound;
14814  item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14815  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14816  H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14817  hid_t item_type1val;
14818  item_type1val=H5T_NATIVE_INT;
14819  hid_t item_type1compound;
14820  item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14821  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14822  H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14823  item_type0=sha1_type_;
14824  if(vldts_.count(VL_MAP_PAIR_VL_STRING_VL_STRING_INT)==0){
14825  vldts_[VL_MAP_PAIR_VL_STRING_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
14826  opened_types_.insert(vldts_[VL_MAP_PAIR_VL_STRING_VL_STRING_INT]);
14827 
14828  }
14829  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14830  field_types[i]=sha1_type_;
14831 
14832  }else if(shape[0]>=1&&shape[2]>=1&&shape[3]<1){
14833  dbtypes[i]=MAP_PAIR_STRING_VL_STRING_INT;
14834  hid_t item_type0;
14835  hsize_t shape01=shape[0];
14836  hid_t item_type1key;
14837  hid_t item_type2first;
14838  item_type2first=CreateFLStrType(shape[2]);
14839  hid_t item_type2second;
14840  item_type2second=sha1_type_;
14841  hid_t item_type2keycompound;
14842  item_type2keycompound=H5Tcreate(H5T_COMPOUND, shape[2]+CYCLUS_SHA1_SIZE);
14843  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14844  H5Tinsert(item_type2keycompound, "second", 0+shape[2], item_type2second);
14845  hid_t item_type1val;
14846  item_type1val=H5T_NATIVE_INT;
14847  hid_t item_type1compound;
14848  item_type1compound=H5Tcreate(H5T_COMPOUND, ((shape[2]+CYCLUS_SHA1_SIZE))+sizeof(int));
14849  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14850  H5Tinsert(item_type1compound, "val", 0+((shape[2]+CYCLUS_SHA1_SIZE)), item_type1val);
14851  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
14852  dst_sizes[i]=((((shape[2]+CYCLUS_SHA1_SIZE))+sizeof(int))*shape[0]);
14853  field_types[i]=item_type0;
14854  opened_types_.insert(item_type2keycompound);
14855  opened_types_.insert(item_type1compound);
14856  opened_types_.insert(field_types[i]);
14857 
14858  }else if(shape[0]>=1&&shape[2]<1&&shape[3]>=1){
14859  dbtypes[i]=MAP_PAIR_VL_STRING_STRING_INT;
14860  hid_t item_type0;
14861  hsize_t shape01=shape[0];
14862  hid_t item_type1key;
14863  hid_t item_type2first;
14864  item_type2first=sha1_type_;
14865  hid_t item_type2second;
14866  item_type2second=CreateFLStrType(shape[3]);
14867  hid_t item_type2keycompound;
14868  item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+shape[3]);
14869  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14870  H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14871  hid_t item_type1val;
14872  item_type1val=H5T_NATIVE_INT;
14873  hid_t item_type1compound;
14874  item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+shape[3]))+sizeof(int));
14875  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14876  H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+shape[3])), item_type1val);
14877  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
14878  dst_sizes[i]=((((CYCLUS_SHA1_SIZE+shape[3]))+sizeof(int))*shape[0]);
14879  field_types[i]=item_type0;
14880  opened_types_.insert(item_type2keycompound);
14881  opened_types_.insert(item_type1compound);
14882  opened_types_.insert(field_types[i]);
14883 
14884  }else if(shape[0]>=1&&shape[2]<1&&shape[3]<1){
14886  hid_t item_type0;
14887  hsize_t shape01=shape[0];
14888  hid_t item_type1key;
14889  hid_t item_type2first;
14890  item_type2first=sha1_type_;
14891  hid_t item_type2second;
14892  item_type2second=sha1_type_;
14893  hid_t item_type2keycompound;
14894  item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14895  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14896  H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14897  hid_t item_type1val;
14898  item_type1val=H5T_NATIVE_INT;
14899  hid_t item_type1compound;
14900  item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14901  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14902  H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14903  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
14904  dst_sizes[i]=((((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int))*shape[0]);
14905  field_types[i]=item_type0;
14906  opened_types_.insert(item_type2keycompound);
14907  opened_types_.insert(item_type1compound);
14908  opened_types_.insert(field_types[i]);
14909 
14910  }else if(shape[0]<1&&shape[2]>=1&&shape[3]>=1){
14911  dbtypes[i]=VL_MAP_PAIR_STRING_STRING_INT;
14912  hid_t item_type0;
14913  hid_t item_type1key;
14914  hid_t item_type2first;
14915  item_type2first=sha1_type_;
14916  hid_t item_type2second;
14917  item_type2second=sha1_type_;
14918  hid_t item_type2keycompound;
14919  item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14920  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14921  H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14922  hid_t item_type1val;
14923  item_type1val=H5T_NATIVE_INT;
14924  hid_t item_type1compound;
14925  item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14926  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14927  H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14928  item_type0=sha1_type_;
14929  if(vldts_.count(VL_MAP_PAIR_STRING_STRING_INT)==0){
14930  vldts_[VL_MAP_PAIR_STRING_STRING_INT]=H5Tvlen_create(item_type1compound);
14931  opened_types_.insert(vldts_[VL_MAP_PAIR_STRING_STRING_INT]);
14932 
14933  }
14934  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14935  field_types[i]=sha1_type_;
14936 
14937  }else if(shape[0]<1&&shape[2]>=1&&shape[3]<1){
14939  hid_t item_type0;
14940  hid_t item_type1key;
14941  hid_t item_type2first;
14942  item_type2first=sha1_type_;
14943  hid_t item_type2second;
14944  item_type2second=sha1_type_;
14945  hid_t item_type2keycompound;
14946  item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14947  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14948  H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14949  hid_t item_type1val;
14950  item_type1val=H5T_NATIVE_INT;
14951  hid_t item_type1compound;
14952  item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14953  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14954  H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14955  item_type0=sha1_type_;
14956  if(vldts_.count(VL_MAP_PAIR_STRING_VL_STRING_INT)==0){
14957  vldts_[VL_MAP_PAIR_STRING_VL_STRING_INT]=H5Tvlen_create(item_type1compound);
14958  opened_types_.insert(vldts_[VL_MAP_PAIR_STRING_VL_STRING_INT]);
14959 
14960  }
14961  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14962  field_types[i]=sha1_type_;
14963 
14964  }else if(shape[0]<1&&shape[2]<1&&shape[3]>=1){
14966  hid_t item_type0;
14967  hid_t item_type1key;
14968  hid_t item_type2first;
14969  item_type2first=sha1_type_;
14970  hid_t item_type2second;
14971  item_type2second=sha1_type_;
14972  hid_t item_type2keycompound;
14973  item_type2keycompound=H5Tcreate(H5T_COMPOUND, CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE);
14974  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
14975  H5Tinsert(item_type2keycompound, "second", 0+CYCLUS_SHA1_SIZE, item_type2second);
14976  hid_t item_type1val;
14977  item_type1val=H5T_NATIVE_INT;
14978  hid_t item_type1compound;
14979  item_type1compound=H5Tcreate(H5T_COMPOUND, ((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int));
14980  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
14981  H5Tinsert(item_type1compound, "val", 0+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)), item_type1val);
14982  item_type0=sha1_type_;
14983  if(vldts_.count(VL_MAP_PAIR_VL_STRING_STRING_INT)==0){
14984  vldts_[VL_MAP_PAIR_VL_STRING_STRING_INT]=H5Tvlen_create(item_type1compound);
14985  opened_types_.insert(vldts_[VL_MAP_PAIR_VL_STRING_STRING_INT]);
14986 
14987  }
14988  dst_sizes[i]=(CYCLUS_SHA1_SIZE);
14989  field_types[i]=sha1_type_;
14990 
14991  }else{
14992  dbtypes[i]=MAP_PAIR_STRING_STRING_INT;
14993  hid_t item_type0;
14994  hsize_t shape01=shape[0];
14995  hid_t item_type1key;
14996  hid_t item_type2first;
14997  item_type2first=CreateFLStrType(shape[2]);
14998  hid_t item_type2second;
14999  item_type2second=CreateFLStrType(shape[3]);
15000  hid_t item_type2keycompound;
15001  item_type2keycompound=H5Tcreate(H5T_COMPOUND, shape[2]+shape[3]);
15002  H5Tinsert(item_type2keycompound, "first", 0, item_type2first);
15003  H5Tinsert(item_type2keycompound, "second", 0+shape[2], item_type2second);
15004  hid_t item_type1val;
15005  item_type1val=H5T_NATIVE_INT;
15006  hid_t item_type1compound;
15007  item_type1compound=H5Tcreate(H5T_COMPOUND, ((shape[2]+shape[3]))+sizeof(int));
15008  H5Tinsert(item_type1compound, "key", 0, item_type2keycompound);
15009  H5Tinsert(item_type1compound, "val", 0+((shape[2]+shape[3])), item_type1val);
15010  item_type0=H5Tarray_create2(item_type1compound, 1, &shape01);
15011  dst_sizes[i]=((((shape[2]+shape[3]))+sizeof(int))*shape[0]);
15012  field_types[i]=item_type0;
15013  opened_types_.insert(item_type2keycompound);
15014  opened_types_.insert(item_type1compound);
15015  opened_types_.insert(field_types[i]);
15016 
15017  }
15018 
15019  }else{
15020  throw IOError("the type for column '"+std::string(field_names[i])+"' is not yet supported in HDF5.");
15021  }
15022 
15023 
15024  dst_size += dst_sizes[i];
15025  }
15026 
15027  std::string titlestr = d->title();
15028  const char* title = titlestr.c_str();
15029  int compress = 1;
15030  int chunk_size = 1024;
15031  void* fill_data = NULL;
15032  void* data = NULL;
15033 
15034  // Make the table
15035  status = H5TBmake_table(title, file_, title, nvals, 0, dst_size,
15036  field_names, dst_offset, field_types, chunk_size,
15037  fill_data, compress, data);
15038  if (status < 0) {
15039  std::stringstream ss;
15040  ss << "Failed to create HDF5 table:\n" \
15041  << " file " << path_ << "\n" \
15042  << " table " << title << "\n" \
15043  << " chunksize " << chunk_size << "\n" \
15044  << " rowsize " << dst_size << "\n";
15045  for (int i = 0; i < nvals; ++i) {
15046  ss << " #" << i << " " << field_names[i] << "\n" \
15047  << " dbtype: " << dbtypes[i] << "\n" \
15048  << " h5type: " << field_types[i] << "\n" \
15049  << " size: " << dst_sizes[i] << "\n" \
15050  << " offset: " << dst_offset[i] << "\n";
15051  }
15052  throw IOError(ss.str());
15053  }
15054 
15055  // add dbtypes attribute
15056  hid_t tb_set = H5Dopen2(file_, title, H5P_DEFAULT);
15057  hid_t attr_space = H5Screate_simple(1, &nvals, &nvals);
15058  hid_t dbtypes_attr = H5Acreate2(tb_set, "cyclus_dbtypes", H5T_NATIVE_INT,
15059  attr_space, H5P_DEFAULT, H5P_DEFAULT);
15060  H5Awrite(dbtypes_attr, H5T_NATIVE_INT, dbtypes);
15061  H5Aclose(dbtypes_attr);
15062  H5Sclose(attr_space);
15063  for(int i = 0; i < nvals; ++i) {
15064  shape = shapes[i];
15065  hsize_t nshape = shape.size();
15066  // if no shape is present, we set a primitive size of 1.
15067  if(shape.size() == 0) {
15068  nshape = 1;
15069  }
15070  hid_t shape_space = H5Screate_simple(1, &nshape, &nshape);
15071  std::vector<int> shape_vector;
15072  for(int j = 0; j < shape.size(); ++j) {
15073  shape_vector.push_back(shape[j]);
15074  }
15075  // default shape value is -1, which denotes primitives
15076  if(shape.size() == 0) {
15077  shape_vector.push_back(-1);
15078  }
15079  std::stringstream col_name;
15080  col_name << "shape" << i;
15081  hid_t shape_attr = H5Acreate2(tb_set, col_name.str().c_str(), H5T_NATIVE_INT,
15082  shape_space, H5P_DEFAULT, H5P_DEFAULT);
15083  H5Awrite(shape_attr, H5T_NATIVE_INT, &shape_vector[0]);
15084  H5Aclose(shape_attr);
15085  H5Sclose(shape_space);
15086  }
15087  H5Dclose(tb_set);
15088 
15089  // record everything for later
15090  col_offsets_[d->title()] = dst_offset;
15091  schema_sizes_[d->title()] = dst_size;
15092  col_sizes_[d->title()] = dst_sizes;
15093  schemas_[d->title()] = dbtypes;
15094 }
15095 
15096 std::map<std::string, DbTypes> Hdf5Back::ColumnTypes(std::string table) {
15097  using std::string;
15098  int i;
15099  char* colname;
15100  hid_t dset = H5Dopen2(file_, table.c_str(), H5P_DEFAULT);
15101  hid_t dt = H5Dget_type(dset);
15102  hsize_t ncols = H5Tget_nmembers(dt);
15103  string fieldname;
15104  string fieldtype;
15105  LoadTableTypes(table, dset, ncols);
15106  DbTypes* dbtypes = schemas_[table];
15107 
15108  // create return value
15109  std::map<string, DbTypes> rtn;
15110  for (i = 0; i < ncols; ++i) {
15111  colname = H5Tget_member_name(dt, i);
15112  fieldname = string(colname);
15113  free(colname);
15114  rtn[fieldname] = dbtypes[i];
15115  }
15116 
15117  // close and return
15118  H5Tclose(dt);
15119  H5Dclose(dset);
15120  return rtn;
15121 }
15122 
15123 std::list<ColumnInfo> Hdf5Back::Schema(std::string table) {
15124  std::list<ColumnInfo> schema;
15125  hid_t tb_set = H5Dopen2(file_, table.c_str(), H5P_DEFAULT);
15126  hid_t tb_type = H5Dget_type(tb_set);
15127  int i;
15128  hsize_t ncols = H5Tget_nmembers(tb_type);
15129  LoadTableTypes(table, tb_set, ncols);
15130  DbTypes* dbtypes = schemas_[table];
15131  char * colname;
15132 
15133  for (i = 0; i < ncols; ++i) {
15134  colname = H5Tget_member_name(tb_type, i);
15135  std::stringstream attr_name;
15136  attr_name << "shape" << i;
15137  hid_t attr_id = H5Aopen_by_name(tb_set, ".", attr_name.str().c_str(), H5P_DEFAULT, H5P_DEFAULT);
15138  hid_t attr_space = H5Aget_space(attr_id);
15139  int ndims = H5Sget_simple_extent_npoints(attr_space);
15140  std::vector<int> shape(ndims);
15141  H5Aread(attr_id, H5T_NATIVE_INT, &shape[0]);
15142  std::string colname_str = std::string(colname);
15143  ColumnInfo info = ColumnInfo(table, colname_str, i, dbtypes[i], shape);
15144  schema.push_back(info);
15145  free(colname);
15146  H5Sclose(attr_space);
15147  H5Aclose(attr_id);
15148  }
15149  H5Tclose(tb_type);
15150  H5Dclose(tb_set);
15151 
15152  return schema;
15153 }
15154 
15155 std::set<std::string> Hdf5Back::Tables() {
15156  using std::set;
15157  using std::string;
15158  set<string> rtn;
15159  hsize_t i;
15160  hsize_t n;
15161  ssize_t namelen;
15162  char name[500];
15163  H5G_info_t root_info;
15164  hid_t root = H5Gopen(file_, "/", H5P_DEFAULT);
15165  herr_t err = H5Gget_info(root, &root_info);
15166  for (i = 0; i < root_info.nlinks; ++i) {
15167  namelen = H5Lget_name_by_idx(root, ".", H5_INDEX_NAME, H5_ITER_NATIVE, i,
15168  NULL, 0, H5P_DEFAULT);
15169  H5Lget_name_by_idx(root, ".", H5_INDEX_NAME, H5_ITER_NATIVE, i,
15170  name, namelen+1, H5P_DEFAULT);
15171  std::string str_name = std::string(name, namelen);
15172  if (str_name.size() >= 4 && str_name.substr(str_name.size()-4) != "Keys" && str_name.substr(str_name.size()-4) != "Vals") {
15173  rtn.insert(str_name);
15174  } else if (str_name.size() < 4) {
15175  rtn.insert(str_name);
15176  }
15177  }
15178  H5Gclose(root);
15179  return rtn;
15180 }
15181 
15182 void Hdf5Back::WriteGroup(DatumList& group) {
15183  std::string title = group.front()->title();
15184  const char * c_title = title.c_str();
15185 
15186  size_t* offsets = col_offsets_[title];
15187  size_t* sizes = col_sizes_[title];
15188  size_t rowsize = schema_sizes_[title];
15189 
15190  char* buf = new char[group.size() * rowsize];
15191  FillBuf(title, buf, group, sizes, rowsize);
15192 
15193  // We cannot do the simple thing (append_records) here because of a bug in
15194  // H5TB where it stupidly tries to reconstruct the datatype in memory from
15195  // what it read in on disk. This works in most cases but failed where the table
15196  // had a column which is an array of a compound datatype of non-homogenous
15197  // fields (eg MAP_INT_DOUBLE). The fix here just uses the datatype present on
15198  // disk - which is what we wanted anyway!
15199  //herr_t status = H5TBappend_records(file_, title.c_str(), group.size(), rowsize,
15200  // offsets, sizes, buf);
15201  herr_t status;
15202  hid_t dset = H5Dopen2(file_, title.c_str(), H5P_DEFAULT);
15203  hid_t dtype = H5Dget_type(dset);
15204  hsize_t nrecords_add = group.size();
15205  hsize_t nrecords_orig;
15206  hsize_t nfields;
15207  hsize_t dims[1];
15208  hsize_t offset[1];
15209  hsize_t count[1];
15210  H5TBget_table_info(file_, c_title, &nfields, &nrecords_orig);
15211  dims[0] = nrecords_add + nrecords_orig;
15212  offset[0] = nrecords_orig;
15213  count[0] = nrecords_add;
15214 
15215  status = H5Dset_extent(dset, dims);
15216  hid_t dspace = H5Dget_space(dset);
15217  hid_t memspace = H5Screate_simple(1, count, NULL);
15218  status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, offset, NULL, count, NULL);
15219  status = H5Dwrite(dset, dtype, memspace, dspace, H5P_DEFAULT, buf);
15220 
15221  if (status < 0) {
15222  std::stringstream ss;
15223  ss << "Failed to write to the HDF5 table:\n" \
15224  << " file " << path_ << "\n" \
15225  << " table " << title << "\n" \
15226  << " num. rows " << group.size() << "\n"
15227  << " rowsize " << rowsize << "\n";
15228  for (int i = 0; i < group.front()->vals().size(); ++i) {
15229  ss << " # Column " << i << "\n" \
15230  << " dbtype: " << schemas_[title][i] << "\n" \
15231  << " size: " << sizes[i] << "\n" \
15232  << " offset: " << offsets[i] << "\n";
15233  }
15234  throw IOError(ss.str());
15235  }
15236 
15237  H5Sclose(memspace);
15238  H5Sclose(dspace);
15239  H5Tclose(dtype);
15240  H5Dclose(dset);
15241  delete[] buf;
15242 }
15243 
15244 template <typename T, DbTypes U>
15245 Digest Hdf5Back::VLWrite(const T& x) {
15246  hasher_.Clear();
15247  hasher_.Update(x);
15248  Digest key = hasher_.digest();
15249  hid_t keysds = VLDataset(U, true);
15250  hid_t valsds = VLDataset(U, false);
15251  if (vlkeys_[U].count(key) == 1)
15252  return key;
15253  hvl_t buf = VLValToBuf(x);
15254  AppendVLKey(keysds, U, key);
15255  InsertVLVal(valsds, U, key, buf);
15256  return key;
15257 }
15258 
15259 template <>
15260 Digest Hdf5Back::VLWrite<std::string, VL_STRING>(const std::string& x) {
15261  hasher_.Clear();
15262  hasher_.Update(x);
15263  Digest key = hasher_.digest();
15264  hid_t keysds = VLDataset(VL_STRING, true);
15265  hid_t valsds = VLDataset(VL_STRING, false);
15266  if (vlkeys_[VL_STRING].count(key) == 1)
15267  return key;
15268  AppendVLKey(keysds, VL_STRING, key);
15269  InsertVLVal(valsds, VL_STRING, key, x);
15270  return key;
15271 }
15272 
15273 template <>
15274 Digest Hdf5Back::VLWrite<Blob, BLOB>(const Blob& x) {
15275  hasher_.Clear();
15276  hasher_.Update(x);
15277  Digest key = hasher_.digest();
15278  hid_t keysds = VLDataset(BLOB, true);
15279  hid_t valsds = VLDataset(BLOB, false);
15280  if (vlkeys_[BLOB].count(key) == 1)
15281  return key;
15282  AppendVLKey(keysds, BLOB, key);
15283  InsertVLVal(valsds, BLOB, key, x.str());
15284  return key;
15285 }
15286 
15287 template<>
15288 void Hdf5Back::WriteToBuf<BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15289  const void* val0;
15290  val0=a->castsmallvoid();
15291  size_t item_size0=sizeof(char);
15292  memcpy(buf, val0, column);
15293 }
15294 template<>
15295 void Hdf5Back::WriteToBuf<INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15296  const void* val0;
15297  val0=a->castsmallvoid();
15298  size_t item_size0=sizeof(int);
15299  memcpy(buf, val0, column);
15300 }
15301 template<>
15302 void Hdf5Back::WriteToBuf<FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15303  const void* val0;
15304  val0=a->castsmallvoid();
15305  size_t item_size0=sizeof(float);
15306  memcpy(buf, val0, column);
15307 }
15308 template<>
15309 void Hdf5Back::WriteToBuf<DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15310  const void* val0;
15311  val0=a->castsmallvoid();
15312  size_t item_size0=sizeof(double);
15313  memcpy(buf, val0, column);
15314 }
15315 template<>
15316 void Hdf5Back::WriteToBuf<STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15317  std::string val0=a->cast<std::string>();
15318  size_t item_size0=shape[0];
15319  size_t valuelen0;
15320  valuelen0=std::min(val0.size(), item_size0);
15321  memcpy(buf, val0.c_str(), valuelen0);
15322  memset(buf+valuelen0, 0, item_size0-valuelen0);
15323 }
15324 template<>
15325 void Hdf5Back::WriteToBuf<VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15326  std::string val0=a->cast<std::string>();
15327  size_t item_size0=CYCLUS_SHA1_SIZE;
15328  hasher_.Clear();
15329  hasher_.Update(val0);
15330  Digest key0 = hasher_.digest();
15331  hid_t keysds0 = VLDataset(VL_STRING, true);
15332  hid_t valsds0 = VLDataset(VL_STRING, false);
15333  if (vlkeys_[VL_STRING].count(key0) != 1) {
15334  AppendVLKey(keysds0, VL_STRING, key0);
15335  InsertVLVal(valsds0, VL_STRING, key0, val0);
15336  }
15337  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15338 }
15339 template<>
15340 void Hdf5Back::WriteToBuf<BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15341  cyclus::Blob val0=a->cast<cyclus::Blob>();
15342  size_t item_size0=CYCLUS_SHA1_SIZE;
15343  hasher_.Clear();
15344  hasher_.Update(val0);
15345  Digest key0 = hasher_.digest();
15346  hid_t keysds0 = VLDataset(BLOB, true);
15347  hid_t valsds0 = VLDataset(BLOB, false);
15348  if (vlkeys_[BLOB].count(key0) != 1) {
15349  AppendVLKey(keysds0, BLOB, key0);
15350  InsertVLVal(valsds0, BLOB, key0, (val0).str());
15351  }
15352  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15353 }
15354 template<>
15355 void Hdf5Back::WriteToBuf<UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15356  boost::uuids::uuid val0=a->cast<boost::uuids::uuid>();
15357  size_t item_size0=CYCLUS_UUID_SIZE;
15358  memcpy(buf, &(val0), item_size0);
15359 }
15360 template<>
15361 void Hdf5Back::WriteToBuf<VECTOR_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15362  std::vector<int> val0=a->cast<std::vector<int>>();
15363  size_t item_size0=((sizeof(int))*shape[0]);
15364  size_t length0=shape[0];
15365  size_t item_size1elem=sizeof(int);
15366  size_t total_item_size0=item_size1elem;
15367  if(total_item_size0*val0.size()>column){
15368  std::vector<int>::iterator eraseit=val0.begin();
15369  std::advance(eraseit, column/total_item_size0);
15370  val0.erase(eraseit,val0.end());
15371 
15372  }
15373  unsigned int count0=0;
15374  std::vector<int>::iterator it0=val0.begin();
15375  for(;it0!=val0.end();++it0){
15376  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15377  ++count0;
15378 
15379  }
15380  if(total_item_size0*length0<column){
15381  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15382 
15383  }
15384 }
15385 template<>
15386 void Hdf5Back::WriteToBuf<VL_VECTOR_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15387  std::vector<int> val0=a->cast<std::vector<int>>();
15388  size_t item_size0=(CYCLUS_SHA1_SIZE);
15389  size_t item_size1elem=sizeof(int);
15390  size_t total_item_size0=item_size1elem;
15391  hasher_.Clear();
15392  hasher_.Update(val0);
15393  Digest key0 = hasher_.digest();
15394  hid_t keysds0 = VLDataset(VL_VECTOR_INT, true);
15395  hid_t valsds0 = VLDataset(VL_VECTOR_INT, false);
15396  if (vlkeys_[VL_VECTOR_INT].count(key0) != 1) {
15397  hvl_t buf0 = VLValToBuf(val0);
15398  AppendVLKey(keysds0, VL_VECTOR_INT, key0);
15399  InsertVLVal(valsds0, VL_VECTOR_INT, key0, buf0);
15400  }
15401  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15402 }
15403 template<>
15404 void Hdf5Back::WriteToBuf<VECTOR_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15405  std::vector<float> val0=a->cast<std::vector<float>>();
15406  size_t item_size0=((sizeof(float))*shape[0]);
15407  size_t length0=shape[0];
15408  size_t item_size1elem=sizeof(float);
15409  size_t total_item_size0=item_size1elem;
15410  if(total_item_size0*val0.size()>column){
15411  std::vector<float>::iterator eraseit=val0.begin();
15412  std::advance(eraseit, column/total_item_size0);
15413  val0.erase(eraseit,val0.end());
15414 
15415  }
15416  unsigned int count0=0;
15417  std::vector<float>::iterator it0=val0.begin();
15418  for(;it0!=val0.end();++it0){
15419  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15420  ++count0;
15421 
15422  }
15423  if(total_item_size0*length0<column){
15424  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15425 
15426  }
15427 }
15428 template<>
15429 void Hdf5Back::WriteToBuf<VL_VECTOR_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15430  std::vector<float> val0=a->cast<std::vector<float>>();
15431  size_t item_size0=(CYCLUS_SHA1_SIZE);
15432  size_t item_size1elem=sizeof(float);
15433  size_t total_item_size0=item_size1elem;
15434  hasher_.Clear();
15435  hasher_.Update(val0);
15436  Digest key0 = hasher_.digest();
15437  hid_t keysds0 = VLDataset(VL_VECTOR_FLOAT, true);
15438  hid_t valsds0 = VLDataset(VL_VECTOR_FLOAT, false);
15439  if (vlkeys_[VL_VECTOR_FLOAT].count(key0) != 1) {
15440  hvl_t buf0 = VLValToBuf(val0);
15441  AppendVLKey(keysds0, VL_VECTOR_FLOAT, key0);
15442  InsertVLVal(valsds0, VL_VECTOR_FLOAT, key0, buf0);
15443  }
15444  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15445 }
15446 template<>
15447 void Hdf5Back::WriteToBuf<VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15448  std::vector<double> val0=a->cast<std::vector<double>>();
15449  size_t item_size0=((sizeof(double))*shape[0]);
15450  size_t length0=shape[0];
15451  size_t item_size1elem=sizeof(double);
15452  size_t total_item_size0=item_size1elem;
15453  if(total_item_size0*val0.size()>column){
15454  std::vector<double>::iterator eraseit=val0.begin();
15455  std::advance(eraseit, column/total_item_size0);
15456  val0.erase(eraseit,val0.end());
15457 
15458  }
15459  unsigned int count0=0;
15460  std::vector<double>::iterator it0=val0.begin();
15461  for(;it0!=val0.end();++it0){
15462  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15463  ++count0;
15464 
15465  }
15466  if(total_item_size0*length0<column){
15467  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15468 
15469  }
15470 }
15471 template<>
15472 void Hdf5Back::WriteToBuf<VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15473  std::vector<double> val0=a->cast<std::vector<double>>();
15474  size_t item_size0=(CYCLUS_SHA1_SIZE);
15475  size_t item_size1elem=sizeof(double);
15476  size_t total_item_size0=item_size1elem;
15477  hasher_.Clear();
15478  hasher_.Update(val0);
15479  Digest key0 = hasher_.digest();
15480  hid_t keysds0 = VLDataset(VL_VECTOR_DOUBLE, true);
15481  hid_t valsds0 = VLDataset(VL_VECTOR_DOUBLE, false);
15482  if (vlkeys_[VL_VECTOR_DOUBLE].count(key0) != 1) {
15483  hvl_t buf0 = VLValToBuf(val0);
15484  AppendVLKey(keysds0, VL_VECTOR_DOUBLE, key0);
15485  InsertVLVal(valsds0, VL_VECTOR_DOUBLE, key0, buf0);
15486  }
15487  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15488 }
15489 template<>
15490 void Hdf5Back::WriteToBuf<VECTOR_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15491  std::vector<std::string> val0=a->cast<std::vector<std::string>>();
15492  size_t item_size0=((shape[1])*shape[0]);
15493  size_t length0=shape[0];
15494  size_t item_size1elem=shape[1];
15495  size_t valuelen1elem;
15496  size_t total_item_size0=item_size1elem;
15497  if(total_item_size0*val0.size()>column){
15498  std::vector<std::string>::iterator eraseit=val0.begin();
15499  std::advance(eraseit, column/total_item_size0);
15500  val0.erase(eraseit,val0.end());
15501 
15502  }
15503  unsigned int count0=0;
15504  std::vector<std::string>::iterator it0=val0.begin();
15505  for(;it0!=val0.end();++it0){
15506  valuelen1elem=std::min(it0->size(), item_size1elem);
15507  memcpy(buf+item_size1elem*count0, it0->c_str(), valuelen1elem);
15508  memset(buf+item_size1elem*count0+valuelen1elem, 0, item_size1elem-valuelen1elem);
15509  ++count0;
15510 
15511  }
15512  if(total_item_size0*length0<column){
15513  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15514 
15515  }
15516 }
15517 template<>
15518 void Hdf5Back::WriteToBuf<VL_VECTOR_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15519  std::vector<std::string> val0=a->cast<std::vector<std::string>>();
15520  size_t item_size0=(CYCLUS_SHA1_SIZE);
15521  size_t item_size1elem=shape[1];
15522  size_t valuelen1elem;
15523  size_t total_item_size0=item_size1elem;
15524  unsigned int count0=0;
15525  std::vector<std::string>::iterator it0=val0.begin();
15526  std::vector<std::string> fixed_val0;
15527  unsigned int pad_count0=0;
15528  for(;it0!=val0.end();++it0){
15529  std::string child1elem=std::string((*it0),0,item_size1elem);
15530  fixed_val0.push_back(child1elem);
15531  ++pad_count0;
15532 
15533  }
15534  hasher_.Clear();
15535  hasher_.Update(fixed_val0);
15536  Digest key0 = hasher_.digest();
15537  hid_t keysds0 = VLDataset(VL_VECTOR_STRING, true);
15538  hid_t valsds0 = VLDataset(VL_VECTOR_STRING, false);
15539  if (vlkeys_[VL_VECTOR_STRING].count(key0) != 1) {
15540  hvl_t buf0 = VLValToBuf(fixed_val0);
15541  AppendVLKey(keysds0, VL_VECTOR_STRING, key0);
15542  InsertVLVal(valsds0, VL_VECTOR_STRING, key0, buf0);
15543  }
15544  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15545 }
15546 template<>
15547 void Hdf5Back::WriteToBuf<VECTOR_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15548  std::vector<std::string> val0=a->cast<std::vector<std::string>>();
15549  size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
15550  size_t length0=shape[0];
15551  size_t item_size1elem=CYCLUS_SHA1_SIZE;
15552  size_t total_item_size0=item_size1elem;
15553  if(total_item_size0*val0.size()>column){
15554  std::vector<std::string>::iterator eraseit=val0.begin();
15555  std::advance(eraseit, column/total_item_size0);
15556  val0.erase(eraseit,val0.end());
15557 
15558  }
15559  unsigned int count0=0;
15560  std::vector<std::string>::iterator it0=val0.begin();
15561  for(;it0!=val0.end();++it0){
15562  hasher_.Clear();
15563  hasher_.Update(*it0);
15564  Digest key1elem = hasher_.digest();
15565  hid_t keysds1elem = VLDataset(VL_STRING, true);
15566  hid_t valsds1elem = VLDataset(VL_STRING, false);
15567  if (vlkeys_[VL_STRING].count(key1elem) != 1) {
15568  AppendVLKey(keysds1elem, VL_STRING, key1elem);
15569  InsertVLVal(valsds1elem, VL_STRING, key1elem, *it0);
15570  }
15571  memcpy(buf+item_size1elem*count0, key1elem.val, CYCLUS_SHA1_SIZE);
15572  ++count0;
15573 
15574  }
15575  if(total_item_size0*length0<column){
15576  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15577 
15578  }
15579 }
15580 template<>
15581 void Hdf5Back::WriteToBuf<VL_VECTOR_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15582  std::vector<std::string> val0=a->cast<std::vector<std::string>>();
15583  size_t item_size0=(CYCLUS_SHA1_SIZE);
15584  size_t item_size1elem=CYCLUS_SHA1_SIZE;
15585  size_t total_item_size0=item_size1elem;
15586  hasher_.Clear();
15587  hasher_.Update(val0);
15588  Digest key0 = hasher_.digest();
15589  hid_t keysds0 = VLDataset(VL_VECTOR_VL_STRING, true);
15590  hid_t valsds0 = VLDataset(VL_VECTOR_VL_STRING, false);
15591  if (vlkeys_[VL_VECTOR_VL_STRING].count(key0) != 1) {
15592  hvl_t buf0 = VLValToBuf(val0);
15593  AppendVLKey(keysds0, VL_VECTOR_VL_STRING, key0);
15594  InsertVLVal(valsds0, VL_VECTOR_VL_STRING, key0, buf0);
15595  }
15596  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15597 }
15598 template<>
15599 void Hdf5Back::WriteToBuf<VECTOR_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15600  std::vector<cyclus::Blob> val0=a->cast<std::vector<cyclus::Blob>>();
15601  size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
15602  size_t length0=shape[0];
15603  size_t item_size1elem=CYCLUS_SHA1_SIZE;
15604  size_t total_item_size0=item_size1elem;
15605  if(total_item_size0*val0.size()>column){
15606  std::vector<cyclus::Blob>::iterator eraseit=val0.begin();
15607  std::advance(eraseit, column/total_item_size0);
15608  val0.erase(eraseit,val0.end());
15609 
15610  }
15611  unsigned int count0=0;
15612  std::vector<cyclus::Blob>::iterator it0=val0.begin();
15613  for(;it0!=val0.end();++it0){
15614  hasher_.Clear();
15615  hasher_.Update(*it0);
15616  Digest key1elem = hasher_.digest();
15617  hid_t keysds1elem = VLDataset(BLOB, true);
15618  hid_t valsds1elem = VLDataset(BLOB, false);
15619  if (vlkeys_[BLOB].count(key1elem) != 1) {
15620  AppendVLKey(keysds1elem, BLOB, key1elem);
15621  InsertVLVal(valsds1elem, BLOB, key1elem, (*it0).str());
15622  }
15623  memcpy(buf+item_size1elem*count0, key1elem.val, CYCLUS_SHA1_SIZE);
15624  ++count0;
15625 
15626  }
15627  if(total_item_size0*length0<column){
15628  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15629 
15630  }
15631 }
15632 template<>
15633 void Hdf5Back::WriteToBuf<VL_VECTOR_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15634  std::vector<cyclus::Blob> val0=a->cast<std::vector<cyclus::Blob>>();
15635  size_t item_size0=(CYCLUS_SHA1_SIZE);
15636  size_t item_size1elem=CYCLUS_SHA1_SIZE;
15637  size_t total_item_size0=item_size1elem;
15638  hasher_.Clear();
15639  hasher_.Update(val0);
15640  Digest key0 = hasher_.digest();
15641  hid_t keysds0 = VLDataset(VL_VECTOR_BLOB, true);
15642  hid_t valsds0 = VLDataset(VL_VECTOR_BLOB, false);
15643  if (vlkeys_[VL_VECTOR_BLOB].count(key0) != 1) {
15644  hvl_t buf0 = VLValToBuf(val0);
15645  AppendVLKey(keysds0, VL_VECTOR_BLOB, key0);
15646  InsertVLVal(valsds0, VL_VECTOR_BLOB, key0, buf0);
15647  }
15648  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15649 }
15650 template<>
15651 void Hdf5Back::WriteToBuf<VECTOR_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15652  std::vector<boost::uuids::uuid> val0=a->cast<std::vector<boost::uuids::uuid>>();
15653  size_t item_size0=((CYCLUS_UUID_SIZE)*shape[0]);
15654  size_t length0=shape[0];
15655  size_t item_size1elem=CYCLUS_UUID_SIZE;
15656  size_t total_item_size0=item_size1elem;
15657  if(total_item_size0*val0.size()>column){
15658  std::vector<boost::uuids::uuid>::iterator eraseit=val0.begin();
15659  std::advance(eraseit, column/total_item_size0);
15660  val0.erase(eraseit,val0.end());
15661 
15662  }
15663  unsigned int count0=0;
15664  std::vector<boost::uuids::uuid>::iterator it0=val0.begin();
15665  for(;it0!=val0.end();++it0){
15666  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15667  ++count0;
15668 
15669  }
15670  if(total_item_size0*length0<column){
15671  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15672 
15673  }
15674 }
15675 template<>
15676 void Hdf5Back::WriteToBuf<VL_VECTOR_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15677  std::vector<boost::uuids::uuid> val0=a->cast<std::vector<boost::uuids::uuid>>();
15678  size_t item_size0=(CYCLUS_SHA1_SIZE);
15679  size_t item_size1elem=CYCLUS_UUID_SIZE;
15680  size_t total_item_size0=item_size1elem;
15681  hasher_.Clear();
15682  hasher_.Update(val0);
15683  Digest key0 = hasher_.digest();
15684  hid_t keysds0 = VLDataset(VL_VECTOR_UUID, true);
15685  hid_t valsds0 = VLDataset(VL_VECTOR_UUID, false);
15686  if (vlkeys_[VL_VECTOR_UUID].count(key0) != 1) {
15687  hvl_t buf0 = VLValToBuf(val0);
15688  AppendVLKey(keysds0, VL_VECTOR_UUID, key0);
15689  InsertVLVal(valsds0, VL_VECTOR_UUID, key0, buf0);
15690  }
15691  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15692 }
15693 template<>
15694 void Hdf5Back::WriteToBuf<SET_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15695  std::set<int> val0=a->cast<std::set<int>>();
15696  size_t item_size0=((sizeof(int))*shape[0]);
15697  size_t length0=shape[0];
15698  size_t item_size1elem=sizeof(int);
15699  size_t total_item_size0=item_size1elem;
15700  if(total_item_size0*val0.size()>column){
15701  std::set<int>::iterator eraseit=val0.begin();
15702  std::advance(eraseit, column/total_item_size0);
15703  val0.erase(eraseit,val0.end());
15704 
15705  }
15706  unsigned int count0=0;
15707  std::set<int>::iterator it0=val0.begin();
15708  for(;it0!=val0.end();++it0){
15709  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15710  ++count0;
15711 
15712  }
15713  if(total_item_size0*length0<column){
15714  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15715 
15716  }
15717 }
15718 template<>
15719 void Hdf5Back::WriteToBuf<VL_SET_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15720  std::set<int> val0=a->cast<std::set<int>>();
15721  size_t item_size0=(CYCLUS_SHA1_SIZE);
15722  size_t item_size1elem=sizeof(int);
15723  size_t total_item_size0=item_size1elem;
15724  hasher_.Clear();
15725  hasher_.Update(val0);
15726  Digest key0 = hasher_.digest();
15727  hid_t keysds0 = VLDataset(VL_SET_INT, true);
15728  hid_t valsds0 = VLDataset(VL_SET_INT, false);
15729  if (vlkeys_[VL_SET_INT].count(key0) != 1) {
15730  hvl_t buf0 = VLValToBuf(val0);
15731  AppendVLKey(keysds0, VL_SET_INT, key0);
15732  InsertVLVal(valsds0, VL_SET_INT, key0, buf0);
15733  }
15734  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15735 }
15736 template<>
15737 void Hdf5Back::WriteToBuf<SET_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15738  std::set<float> val0=a->cast<std::set<float>>();
15739  size_t item_size0=((sizeof(float))*shape[0]);
15740  size_t length0=shape[0];
15741  size_t item_size1elem=sizeof(float);
15742  size_t total_item_size0=item_size1elem;
15743  if(total_item_size0*val0.size()>column){
15744  std::set<float>::iterator eraseit=val0.begin();
15745  std::advance(eraseit, column/total_item_size0);
15746  val0.erase(eraseit,val0.end());
15747 
15748  }
15749  unsigned int count0=0;
15750  std::set<float>::iterator it0=val0.begin();
15751  for(;it0!=val0.end();++it0){
15752  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15753  ++count0;
15754 
15755  }
15756  if(total_item_size0*length0<column){
15757  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15758 
15759  }
15760 }
15761 template<>
15762 void Hdf5Back::WriteToBuf<VL_SET_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15763  std::set<float> val0=a->cast<std::set<float>>();
15764  size_t item_size0=(CYCLUS_SHA1_SIZE);
15765  size_t item_size1elem=sizeof(float);
15766  size_t total_item_size0=item_size1elem;
15767  hasher_.Clear();
15768  hasher_.Update(val0);
15769  Digest key0 = hasher_.digest();
15770  hid_t keysds0 = VLDataset(VL_SET_FLOAT, true);
15771  hid_t valsds0 = VLDataset(VL_SET_FLOAT, false);
15772  if (vlkeys_[VL_SET_FLOAT].count(key0) != 1) {
15773  hvl_t buf0 = VLValToBuf(val0);
15774  AppendVLKey(keysds0, VL_SET_FLOAT, key0);
15775  InsertVLVal(valsds0, VL_SET_FLOAT, key0, buf0);
15776  }
15777  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15778 }
15779 template<>
15780 void Hdf5Back::WriteToBuf<SET_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15781  std::set<double> val0=a->cast<std::set<double>>();
15782  size_t item_size0=((sizeof(double))*shape[0]);
15783  size_t length0=shape[0];
15784  size_t item_size1elem=sizeof(double);
15785  size_t total_item_size0=item_size1elem;
15786  if(total_item_size0*val0.size()>column){
15787  std::set<double>::iterator eraseit=val0.begin();
15788  std::advance(eraseit, column/total_item_size0);
15789  val0.erase(eraseit,val0.end());
15790 
15791  }
15792  unsigned int count0=0;
15793  std::set<double>::iterator it0=val0.begin();
15794  for(;it0!=val0.end();++it0){
15795  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
15796  ++count0;
15797 
15798  }
15799  if(total_item_size0*length0<column){
15800  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15801 
15802  }
15803 }
15804 template<>
15805 void Hdf5Back::WriteToBuf<VL_SET_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15806  std::set<double> val0=a->cast<std::set<double>>();
15807  size_t item_size0=(CYCLUS_SHA1_SIZE);
15808  size_t item_size1elem=sizeof(double);
15809  size_t total_item_size0=item_size1elem;
15810  hasher_.Clear();
15811  hasher_.Update(val0);
15812  Digest key0 = hasher_.digest();
15813  hid_t keysds0 = VLDataset(VL_SET_DOUBLE, true);
15814  hid_t valsds0 = VLDataset(VL_SET_DOUBLE, false);
15815  if (vlkeys_[VL_SET_DOUBLE].count(key0) != 1) {
15816  hvl_t buf0 = VLValToBuf(val0);
15817  AppendVLKey(keysds0, VL_SET_DOUBLE, key0);
15818  InsertVLVal(valsds0, VL_SET_DOUBLE, key0, buf0);
15819  }
15820  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15821 }
15822 template<>
15823 void Hdf5Back::WriteToBuf<SET_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15824  std::set<std::string> val0=a->cast<std::set<std::string>>();
15825  size_t item_size0=((shape[1])*shape[0]);
15826  size_t length0=shape[0];
15827  size_t item_size1elem=shape[1];
15828  size_t valuelen1elem;
15829  size_t total_item_size0=item_size1elem;
15830  if(total_item_size0*val0.size()>column){
15831  std::set<std::string>::iterator eraseit=val0.begin();
15832  std::advance(eraseit, column/total_item_size0);
15833  val0.erase(eraseit,val0.end());
15834 
15835  }
15836  unsigned int count0=0;
15837  std::set<std::string>::iterator it0=val0.begin();
15838  for(;it0!=val0.end();++it0){
15839  valuelen1elem=std::min(it0->size(), item_size1elem);
15840  memcpy(buf+item_size1elem*count0, it0->c_str(), valuelen1elem);
15841  memset(buf+item_size1elem*count0+valuelen1elem, 0, item_size1elem-valuelen1elem);
15842  ++count0;
15843 
15844  }
15845  if(total_item_size0*length0<column){
15846  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15847 
15848  }
15849 }
15850 template<>
15851 void Hdf5Back::WriteToBuf<VL_SET_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15852  std::set<std::string> val0=a->cast<std::set<std::string>>();
15853  size_t item_size0=(CYCLUS_SHA1_SIZE);
15854  size_t item_size1elem=shape[1];
15855  size_t valuelen1elem;
15856  size_t total_item_size0=item_size1elem;
15857  unsigned int count0=0;
15858  std::set<std::string>::iterator it0=val0.begin();
15859  std::set<std::string> fixed_val0;
15860  unsigned int pad_count0=0;
15861  for(;it0!=val0.end();++it0){
15862  std::string child1elem=std::string((*it0),0,item_size1elem);
15863  fixed_val0.insert(child1elem);
15864  ++pad_count0;
15865 
15866  }
15867  hasher_.Clear();
15868  hasher_.Update(fixed_val0);
15869  Digest key0 = hasher_.digest();
15870  hid_t keysds0 = VLDataset(VL_SET_STRING, true);
15871  hid_t valsds0 = VLDataset(VL_SET_STRING, false);
15872  if (vlkeys_[VL_SET_STRING].count(key0) != 1) {
15873  hvl_t buf0 = VLValToBuf(fixed_val0);
15874  AppendVLKey(keysds0, VL_SET_STRING, key0);
15875  InsertVLVal(valsds0, VL_SET_STRING, key0, buf0);
15876  }
15877  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15878 }
15879 template<>
15880 void Hdf5Back::WriteToBuf<SET_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15881  std::set<std::string> val0=a->cast<std::set<std::string>>();
15882  size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
15883  size_t length0=shape[0];
15884  size_t item_size1elem=CYCLUS_SHA1_SIZE;
15885  size_t total_item_size0=item_size1elem;
15886  if(total_item_size0*val0.size()>column){
15887  std::set<std::string>::iterator eraseit=val0.begin();
15888  std::advance(eraseit, column/total_item_size0);
15889  val0.erase(eraseit,val0.end());
15890 
15891  }
15892  unsigned int count0=0;
15893  std::set<std::string>::iterator it0=val0.begin();
15894  for(;it0!=val0.end();++it0){
15895  hasher_.Clear();
15896  hasher_.Update(*it0);
15897  Digest key1elem = hasher_.digest();
15898  hid_t keysds1elem = VLDataset(VL_STRING, true);
15899  hid_t valsds1elem = VLDataset(VL_STRING, false);
15900  if (vlkeys_[VL_STRING].count(key1elem) != 1) {
15901  AppendVLKey(keysds1elem, VL_STRING, key1elem);
15902  InsertVLVal(valsds1elem, VL_STRING, key1elem, *it0);
15903  }
15904  memcpy(buf+item_size1elem*count0, key1elem.val, CYCLUS_SHA1_SIZE);
15905  ++count0;
15906 
15907  }
15908  if(total_item_size0*length0<column){
15909  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15910 
15911  }
15912 }
15913 template<>
15914 void Hdf5Back::WriteToBuf<VL_SET_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15915  std::set<std::string> val0=a->cast<std::set<std::string>>();
15916  size_t item_size0=(CYCLUS_SHA1_SIZE);
15917  size_t item_size1elem=CYCLUS_SHA1_SIZE;
15918  size_t total_item_size0=item_size1elem;
15919  hasher_.Clear();
15920  hasher_.Update(val0);
15921  Digest key0 = hasher_.digest();
15922  hid_t keysds0 = VLDataset(VL_SET_VL_STRING, true);
15923  hid_t valsds0 = VLDataset(VL_SET_VL_STRING, false);
15924  if (vlkeys_[VL_SET_VL_STRING].count(key0) != 1) {
15925  hvl_t buf0 = VLValToBuf(val0);
15926  AppendVLKey(keysds0, VL_SET_VL_STRING, key0);
15927  InsertVLVal(valsds0, VL_SET_VL_STRING, key0, buf0);
15928  }
15929  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15930 }
15931 template<>
15932 void Hdf5Back::WriteToBuf<SET_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15933  std::set<cyclus::Blob> val0=a->cast<std::set<cyclus::Blob>>();
15934  size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
15935  size_t length0=shape[0];
15936  size_t item_size1elem=CYCLUS_SHA1_SIZE;
15937  size_t total_item_size0=item_size1elem;
15938  if(total_item_size0*val0.size()>column){
15939  std::set<cyclus::Blob>::iterator eraseit=val0.begin();
15940  std::advance(eraseit, column/total_item_size0);
15941  val0.erase(eraseit,val0.end());
15942 
15943  }
15944  unsigned int count0=0;
15945  std::set<cyclus::Blob>::iterator it0=val0.begin();
15946  for(;it0!=val0.end();++it0){
15947  hasher_.Clear();
15948  hasher_.Update(*it0);
15949  Digest key1elem = hasher_.digest();
15950  hid_t keysds1elem = VLDataset(BLOB, true);
15951  hid_t valsds1elem = VLDataset(BLOB, false);
15952  if (vlkeys_[BLOB].count(key1elem) != 1) {
15953  AppendVLKey(keysds1elem, BLOB, key1elem);
15954  InsertVLVal(valsds1elem, BLOB, key1elem, (*it0).str());
15955  }
15956  memcpy(buf+item_size1elem*count0, key1elem.val, CYCLUS_SHA1_SIZE);
15957  ++count0;
15958 
15959  }
15960  if(total_item_size0*length0<column){
15961  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
15962 
15963  }
15964 }
15965 template<>
15966 void Hdf5Back::WriteToBuf<VL_SET_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15967  std::set<cyclus::Blob> val0=a->cast<std::set<cyclus::Blob>>();
15968  size_t item_size0=(CYCLUS_SHA1_SIZE);
15969  size_t item_size1elem=CYCLUS_SHA1_SIZE;
15970  size_t total_item_size0=item_size1elem;
15971  hasher_.Clear();
15972  hasher_.Update(val0);
15973  Digest key0 = hasher_.digest();
15974  hid_t keysds0 = VLDataset(VL_SET_BLOB, true);
15975  hid_t valsds0 = VLDataset(VL_SET_BLOB, false);
15976  if (vlkeys_[VL_SET_BLOB].count(key0) != 1) {
15977  hvl_t buf0 = VLValToBuf(val0);
15978  AppendVLKey(keysds0, VL_SET_BLOB, key0);
15979  InsertVLVal(valsds0, VL_SET_BLOB, key0, buf0);
15980  }
15981  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
15982 }
15983 template<>
15984 void Hdf5Back::WriteToBuf<SET_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
15985  std::set<boost::uuids::uuid> val0=a->cast<std::set<boost::uuids::uuid>>();
15986  size_t item_size0=((CYCLUS_UUID_SIZE)*shape[0]);
15987  size_t length0=shape[0];
15988  size_t item_size1elem=CYCLUS_UUID_SIZE;
15989  size_t total_item_size0=item_size1elem;
15990  if(total_item_size0*val0.size()>column){
15991  std::set<boost::uuids::uuid>::iterator eraseit=val0.begin();
15992  std::advance(eraseit, column/total_item_size0);
15993  val0.erase(eraseit,val0.end());
15994 
15995  }
15996  unsigned int count0=0;
15997  std::set<boost::uuids::uuid>::iterator it0=val0.begin();
15998  for(;it0!=val0.end();++it0){
15999  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16000  ++count0;
16001 
16002  }
16003  if(total_item_size0*length0<column){
16004  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16005 
16006  }
16007 }
16008 template<>
16009 void Hdf5Back::WriteToBuf<VL_SET_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16010  std::set<boost::uuids::uuid> val0=a->cast<std::set<boost::uuids::uuid>>();
16011  size_t item_size0=(CYCLUS_SHA1_SIZE);
16012  size_t item_size1elem=CYCLUS_UUID_SIZE;
16013  size_t total_item_size0=item_size1elem;
16014  hasher_.Clear();
16015  hasher_.Update(val0);
16016  Digest key0 = hasher_.digest();
16017  hid_t keysds0 = VLDataset(VL_SET_UUID, true);
16018  hid_t valsds0 = VLDataset(VL_SET_UUID, false);
16019  if (vlkeys_[VL_SET_UUID].count(key0) != 1) {
16020  hvl_t buf0 = VLValToBuf(val0);
16021  AppendVLKey(keysds0, VL_SET_UUID, key0);
16022  InsertVLVal(valsds0, VL_SET_UUID, key0, buf0);
16023  }
16024  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16025 }
16026 template<>
16027 void Hdf5Back::WriteToBuf<LIST_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16028  std::list<bool> val0=a->cast<std::list<bool>>();
16029  size_t item_size0=((sizeof(char))*shape[0]);
16030  size_t length0=shape[0];
16031  size_t item_size1elem=sizeof(char);
16032  size_t total_item_size0=item_size1elem;
16033  if(total_item_size0*val0.size()>column){
16034  std::list<bool>::iterator eraseit=val0.begin();
16035  std::advance(eraseit, column/total_item_size0);
16036  val0.erase(eraseit,val0.end());
16037 
16038  }
16039  unsigned int count0=0;
16040  std::list<bool>::iterator it0=val0.begin();
16041  for(;it0!=val0.end();++it0){
16042  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16043  ++count0;
16044 
16045  }
16046  if(total_item_size0*length0<column){
16047  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16048 
16049  }
16050 }
16051 template<>
16052 void Hdf5Back::WriteToBuf<VL_LIST_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16053  std::list<bool> val0=a->cast<std::list<bool>>();
16054  size_t item_size0=(CYCLUS_SHA1_SIZE);
16055  size_t item_size1elem=sizeof(char);
16056  size_t total_item_size0=item_size1elem;
16057  hasher_.Clear();
16058  hasher_.Update(val0);
16059  Digest key0 = hasher_.digest();
16060  hid_t keysds0 = VLDataset(VL_LIST_BOOL, true);
16061  hid_t valsds0 = VLDataset(VL_LIST_BOOL, false);
16062  if (vlkeys_[VL_LIST_BOOL].count(key0) != 1) {
16063  hvl_t buf0 = VLValToBuf(val0);
16064  AppendVLKey(keysds0, VL_LIST_BOOL, key0);
16065  InsertVLVal(valsds0, VL_LIST_BOOL, key0, buf0);
16066  }
16067  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16068 }
16069 template<>
16070 void Hdf5Back::WriteToBuf<LIST_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16071  std::list<int> val0=a->cast<std::list<int>>();
16072  size_t item_size0=((sizeof(int))*shape[0]);
16073  size_t length0=shape[0];
16074  size_t item_size1elem=sizeof(int);
16075  size_t total_item_size0=item_size1elem;
16076  if(total_item_size0*val0.size()>column){
16077  std::list<int>::iterator eraseit=val0.begin();
16078  std::advance(eraseit, column/total_item_size0);
16079  val0.erase(eraseit,val0.end());
16080 
16081  }
16082  unsigned int count0=0;
16083  std::list<int>::iterator it0=val0.begin();
16084  for(;it0!=val0.end();++it0){
16085  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16086  ++count0;
16087 
16088  }
16089  if(total_item_size0*length0<column){
16090  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16091 
16092  }
16093 }
16094 template<>
16095 void Hdf5Back::WriteToBuf<VL_LIST_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16096  std::list<int> val0=a->cast<std::list<int>>();
16097  size_t item_size0=(CYCLUS_SHA1_SIZE);
16098  size_t item_size1elem=sizeof(int);
16099  size_t total_item_size0=item_size1elem;
16100  hasher_.Clear();
16101  hasher_.Update(val0);
16102  Digest key0 = hasher_.digest();
16103  hid_t keysds0 = VLDataset(VL_LIST_INT, true);
16104  hid_t valsds0 = VLDataset(VL_LIST_INT, false);
16105  if (vlkeys_[VL_LIST_INT].count(key0) != 1) {
16106  hvl_t buf0 = VLValToBuf(val0);
16107  AppendVLKey(keysds0, VL_LIST_INT, key0);
16108  InsertVLVal(valsds0, VL_LIST_INT, key0, buf0);
16109  }
16110  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16111 }
16112 template<>
16113 void Hdf5Back::WriteToBuf<LIST_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16114  std::list<float> val0=a->cast<std::list<float>>();
16115  size_t item_size0=((sizeof(float))*shape[0]);
16116  size_t length0=shape[0];
16117  size_t item_size1elem=sizeof(float);
16118  size_t total_item_size0=item_size1elem;
16119  if(total_item_size0*val0.size()>column){
16120  std::list<float>::iterator eraseit=val0.begin();
16121  std::advance(eraseit, column/total_item_size0);
16122  val0.erase(eraseit,val0.end());
16123 
16124  }
16125  unsigned int count0=0;
16126  std::list<float>::iterator it0=val0.begin();
16127  for(;it0!=val0.end();++it0){
16128  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16129  ++count0;
16130 
16131  }
16132  if(total_item_size0*length0<column){
16133  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16134 
16135  }
16136 }
16137 template<>
16138 void Hdf5Back::WriteToBuf<VL_LIST_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16139  std::list<float> val0=a->cast<std::list<float>>();
16140  size_t item_size0=(CYCLUS_SHA1_SIZE);
16141  size_t item_size1elem=sizeof(float);
16142  size_t total_item_size0=item_size1elem;
16143  hasher_.Clear();
16144  hasher_.Update(val0);
16145  Digest key0 = hasher_.digest();
16146  hid_t keysds0 = VLDataset(VL_LIST_FLOAT, true);
16147  hid_t valsds0 = VLDataset(VL_LIST_FLOAT, false);
16148  if (vlkeys_[VL_LIST_FLOAT].count(key0) != 1) {
16149  hvl_t buf0 = VLValToBuf(val0);
16150  AppendVLKey(keysds0, VL_LIST_FLOAT, key0);
16151  InsertVLVal(valsds0, VL_LIST_FLOAT, key0, buf0);
16152  }
16153  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16154 }
16155 template<>
16156 void Hdf5Back::WriteToBuf<LIST_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16157  std::list<double> val0=a->cast<std::list<double>>();
16158  size_t item_size0=((sizeof(double))*shape[0]);
16159  size_t length0=shape[0];
16160  size_t item_size1elem=sizeof(double);
16161  size_t total_item_size0=item_size1elem;
16162  if(total_item_size0*val0.size()>column){
16163  std::list<double>::iterator eraseit=val0.begin();
16164  std::advance(eraseit, column/total_item_size0);
16165  val0.erase(eraseit,val0.end());
16166 
16167  }
16168  unsigned int count0=0;
16169  std::list<double>::iterator it0=val0.begin();
16170  for(;it0!=val0.end();++it0){
16171  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16172  ++count0;
16173 
16174  }
16175  if(total_item_size0*length0<column){
16176  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16177 
16178  }
16179 }
16180 template<>
16181 void Hdf5Back::WriteToBuf<VL_LIST_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16182  std::list<double> val0=a->cast<std::list<double>>();
16183  size_t item_size0=(CYCLUS_SHA1_SIZE);
16184  size_t item_size1elem=sizeof(double);
16185  size_t total_item_size0=item_size1elem;
16186  hasher_.Clear();
16187  hasher_.Update(val0);
16188  Digest key0 = hasher_.digest();
16189  hid_t keysds0 = VLDataset(VL_LIST_DOUBLE, true);
16190  hid_t valsds0 = VLDataset(VL_LIST_DOUBLE, false);
16191  if (vlkeys_[VL_LIST_DOUBLE].count(key0) != 1) {
16192  hvl_t buf0 = VLValToBuf(val0);
16193  AppendVLKey(keysds0, VL_LIST_DOUBLE, key0);
16194  InsertVLVal(valsds0, VL_LIST_DOUBLE, key0, buf0);
16195  }
16196  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16197 }
16198 template<>
16199 void Hdf5Back::WriteToBuf<LIST_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16200  std::list<std::string> val0=a->cast<std::list<std::string>>();
16201  size_t item_size0=((shape[1])*shape[0]);
16202  size_t length0=shape[0];
16203  size_t item_size1elem=shape[1];
16204  size_t valuelen1elem;
16205  size_t total_item_size0=item_size1elem;
16206  if(total_item_size0*val0.size()>column){
16207  std::list<std::string>::iterator eraseit=val0.begin();
16208  std::advance(eraseit, column/total_item_size0);
16209  val0.erase(eraseit,val0.end());
16210 
16211  }
16212  unsigned int count0=0;
16213  std::list<std::string>::iterator it0=val0.begin();
16214  for(;it0!=val0.end();++it0){
16215  valuelen1elem=std::min(it0->size(), item_size1elem);
16216  memcpy(buf+item_size1elem*count0, it0->c_str(), valuelen1elem);
16217  memset(buf+item_size1elem*count0+valuelen1elem, 0, item_size1elem-valuelen1elem);
16218  ++count0;
16219 
16220  }
16221  if(total_item_size0*length0<column){
16222  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16223 
16224  }
16225 }
16226 template<>
16227 void Hdf5Back::WriteToBuf<VL_LIST_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16228  std::list<std::string> val0=a->cast<std::list<std::string>>();
16229  size_t item_size0=(CYCLUS_SHA1_SIZE);
16230  size_t item_size1elem=shape[1];
16231  size_t valuelen1elem;
16232  size_t total_item_size0=item_size1elem;
16233  unsigned int count0=0;
16234  std::list<std::string>::iterator it0=val0.begin();
16235  std::list<std::string> fixed_val0;
16236  unsigned int pad_count0=0;
16237  for(;it0!=val0.end();++it0){
16238  std::string child1elem=std::string((*it0),0,item_size1elem);
16239  fixed_val0.push_back(child1elem);
16240  ++pad_count0;
16241 
16242  }
16243  hasher_.Clear();
16244  hasher_.Update(fixed_val0);
16245  Digest key0 = hasher_.digest();
16246  hid_t keysds0 = VLDataset(VL_LIST_STRING, true);
16247  hid_t valsds0 = VLDataset(VL_LIST_STRING, false);
16248  if (vlkeys_[VL_LIST_STRING].count(key0) != 1) {
16249  hvl_t buf0 = VLValToBuf(fixed_val0);
16250  AppendVLKey(keysds0, VL_LIST_STRING, key0);
16251  InsertVLVal(valsds0, VL_LIST_STRING, key0, buf0);
16252  }
16253  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16254 }
16255 template<>
16256 void Hdf5Back::WriteToBuf<LIST_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16257  std::list<std::string> val0=a->cast<std::list<std::string>>();
16258  size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
16259  size_t length0=shape[0];
16260  size_t item_size1elem=CYCLUS_SHA1_SIZE;
16261  size_t total_item_size0=item_size1elem;
16262  if(total_item_size0*val0.size()>column){
16263  std::list<std::string>::iterator eraseit=val0.begin();
16264  std::advance(eraseit, column/total_item_size0);
16265  val0.erase(eraseit,val0.end());
16266 
16267  }
16268  unsigned int count0=0;
16269  std::list<std::string>::iterator it0=val0.begin();
16270  for(;it0!=val0.end();++it0){
16271  hasher_.Clear();
16272  hasher_.Update(*it0);
16273  Digest key1elem = hasher_.digest();
16274  hid_t keysds1elem = VLDataset(VL_STRING, true);
16275  hid_t valsds1elem = VLDataset(VL_STRING, false);
16276  if (vlkeys_[VL_STRING].count(key1elem) != 1) {
16277  AppendVLKey(keysds1elem, VL_STRING, key1elem);
16278  InsertVLVal(valsds1elem, VL_STRING, key1elem, *it0);
16279  }
16280  memcpy(buf+item_size1elem*count0, key1elem.val, CYCLUS_SHA1_SIZE);
16281  ++count0;
16282 
16283  }
16284  if(total_item_size0*length0<column){
16285  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16286 
16287  }
16288 }
16289 template<>
16290 void Hdf5Back::WriteToBuf<VL_LIST_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16291  std::list<std::string> val0=a->cast<std::list<std::string>>();
16292  size_t item_size0=(CYCLUS_SHA1_SIZE);
16293  size_t item_size1elem=CYCLUS_SHA1_SIZE;
16294  size_t total_item_size0=item_size1elem;
16295  hasher_.Clear();
16296  hasher_.Update(val0);
16297  Digest key0 = hasher_.digest();
16298  hid_t keysds0 = VLDataset(VL_LIST_VL_STRING, true);
16299  hid_t valsds0 = VLDataset(VL_LIST_VL_STRING, false);
16300  if (vlkeys_[VL_LIST_VL_STRING].count(key0) != 1) {
16301  hvl_t buf0 = VLValToBuf(val0);
16302  AppendVLKey(keysds0, VL_LIST_VL_STRING, key0);
16303  InsertVLVal(valsds0, VL_LIST_VL_STRING, key0, buf0);
16304  }
16305  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16306 }
16307 template<>
16308 void Hdf5Back::WriteToBuf<LIST_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16309  std::list<cyclus::Blob> val0=a->cast<std::list<cyclus::Blob>>();
16310  size_t item_size0=((CYCLUS_SHA1_SIZE)*shape[0]);
16311  size_t length0=shape[0];
16312  size_t item_size1elem=CYCLUS_SHA1_SIZE;
16313  size_t total_item_size0=item_size1elem;
16314  if(total_item_size0*val0.size()>column){
16315  std::list<cyclus::Blob>::iterator eraseit=val0.begin();
16316  std::advance(eraseit, column/total_item_size0);
16317  val0.erase(eraseit,val0.end());
16318 
16319  }
16320  unsigned int count0=0;
16321  std::list<cyclus::Blob>::iterator it0=val0.begin();
16322  for(;it0!=val0.end();++it0){
16323  hasher_.Clear();
16324  hasher_.Update(*it0);
16325  Digest key1elem = hasher_.digest();
16326  hid_t keysds1elem = VLDataset(BLOB, true);
16327  hid_t valsds1elem = VLDataset(BLOB, false);
16328  if (vlkeys_[BLOB].count(key1elem) != 1) {
16329  AppendVLKey(keysds1elem, BLOB, key1elem);
16330  InsertVLVal(valsds1elem, BLOB, key1elem, (*it0).str());
16331  }
16332  memcpy(buf+item_size1elem*count0, key1elem.val, CYCLUS_SHA1_SIZE);
16333  ++count0;
16334 
16335  }
16336  if(total_item_size0*length0<column){
16337  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16338 
16339  }
16340 }
16341 template<>
16342 void Hdf5Back::WriteToBuf<VL_LIST_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16343  std::list<cyclus::Blob> val0=a->cast<std::list<cyclus::Blob>>();
16344  size_t item_size0=(CYCLUS_SHA1_SIZE);
16345  size_t item_size1elem=CYCLUS_SHA1_SIZE;
16346  size_t total_item_size0=item_size1elem;
16347  hasher_.Clear();
16348  hasher_.Update(val0);
16349  Digest key0 = hasher_.digest();
16350  hid_t keysds0 = VLDataset(VL_LIST_BLOB, true);
16351  hid_t valsds0 = VLDataset(VL_LIST_BLOB, false);
16352  if (vlkeys_[VL_LIST_BLOB].count(key0) != 1) {
16353  hvl_t buf0 = VLValToBuf(val0);
16354  AppendVLKey(keysds0, VL_LIST_BLOB, key0);
16355  InsertVLVal(valsds0, VL_LIST_BLOB, key0, buf0);
16356  }
16357  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16358 }
16359 template<>
16360 void Hdf5Back::WriteToBuf<LIST_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16361  std::list<boost::uuids::uuid> val0=a->cast<std::list<boost::uuids::uuid>>();
16362  size_t item_size0=((CYCLUS_UUID_SIZE)*shape[0]);
16363  size_t length0=shape[0];
16364  size_t item_size1elem=CYCLUS_UUID_SIZE;
16365  size_t total_item_size0=item_size1elem;
16366  if(total_item_size0*val0.size()>column){
16367  std::list<boost::uuids::uuid>::iterator eraseit=val0.begin();
16368  std::advance(eraseit, column/total_item_size0);
16369  val0.erase(eraseit,val0.end());
16370 
16371  }
16372  unsigned int count0=0;
16373  std::list<boost::uuids::uuid>::iterator it0=val0.begin();
16374  for(;it0!=val0.end();++it0){
16375  memcpy(buf+item_size1elem*count0, &(*it0), item_size1elem);
16376  ++count0;
16377 
16378  }
16379  if(total_item_size0*length0<column){
16380  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16381 
16382  }
16383 }
16384 template<>
16385 void Hdf5Back::WriteToBuf<VL_LIST_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16386  std::list<boost::uuids::uuid> val0=a->cast<std::list<boost::uuids::uuid>>();
16387  size_t item_size0=(CYCLUS_SHA1_SIZE);
16388  size_t item_size1elem=CYCLUS_UUID_SIZE;
16389  size_t total_item_size0=item_size1elem;
16390  hasher_.Clear();
16391  hasher_.Update(val0);
16392  Digest key0 = hasher_.digest();
16393  hid_t keysds0 = VLDataset(VL_LIST_UUID, true);
16394  hid_t valsds0 = VLDataset(VL_LIST_UUID, false);
16395  if (vlkeys_[VL_LIST_UUID].count(key0) != 1) {
16396  hvl_t buf0 = VLValToBuf(val0);
16397  AppendVLKey(keysds0, VL_LIST_UUID, key0);
16398  InsertVLVal(valsds0, VL_LIST_UUID, key0, buf0);
16399  }
16400  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16401 }
16402 template<>
16403 void Hdf5Back::WriteToBuf<PAIR_INT_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16404  std::pair<int, bool> val0=a->cast<std::pair<int, bool>>();
16405  size_t item_size0=((sizeof(int)+sizeof(char)));
16406  size_t item_size1first=sizeof(int);
16407  size_t item_size1second=sizeof(char);
16408  size_t total_item_size0=item_size1first+item_size1second;
16409  unsigned int count0=0;
16410  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16411  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16412 }
16413 template<>
16414 void Hdf5Back::WriteToBuf<PAIR_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16415  std::pair<int, int> val0=a->cast<std::pair<int, int>>();
16416  size_t item_size0=((sizeof(int)+sizeof(int)));
16417  size_t item_size1first=sizeof(int);
16418  size_t item_size1second=sizeof(int);
16419  size_t total_item_size0=item_size1first+item_size1second;
16420  unsigned int count0=0;
16421  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16422  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16423 }
16424 template<>
16425 void Hdf5Back::WriteToBuf<PAIR_INT_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16426  std::pair<int, float> val0=a->cast<std::pair<int, float>>();
16427  size_t item_size0=((sizeof(int)+sizeof(float)));
16428  size_t item_size1first=sizeof(int);
16429  size_t item_size1second=sizeof(float);
16430  size_t total_item_size0=item_size1first+item_size1second;
16431  unsigned int count0=0;
16432  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16433  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16434 }
16435 template<>
16436 void Hdf5Back::WriteToBuf<PAIR_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16437  std::pair<int, double> val0=a->cast<std::pair<int, double>>();
16438  size_t item_size0=((sizeof(int)+sizeof(double)));
16439  size_t item_size1first=sizeof(int);
16440  size_t item_size1second=sizeof(double);
16441  size_t total_item_size0=item_size1first+item_size1second;
16442  unsigned int count0=0;
16443  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16444  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16445 }
16446 template<>
16447 void Hdf5Back::WriteToBuf<PAIR_INT_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16448  std::pair<int, std::string> val0=a->cast<std::pair<int, std::string>>();
16449  size_t item_size0=((sizeof(int)+shape[2]));
16450  size_t item_size1first=sizeof(int);
16451  size_t item_size1second=shape[2];
16452  size_t valuelen1second;
16453  size_t total_item_size0=item_size1first+item_size1second;
16454  unsigned int count0=0;
16455  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16456  valuelen1second=std::min(val0.second.size(), item_size1second);
16457  memcpy(buf+(count0*total_item_size0)+0+item_size1first, val0.second.c_str(), valuelen1second);
16458  memset(buf+(count0*total_item_size0)+0+item_size1first+valuelen1second, 0, item_size1second-valuelen1second);
16459 }
16460 template<>
16461 void Hdf5Back::WriteToBuf<PAIR_INT_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16462  std::pair<int, std::string> val0=a->cast<std::pair<int, std::string>>();
16463  size_t item_size0=((sizeof(int)+CYCLUS_SHA1_SIZE));
16464  size_t item_size1first=sizeof(int);
16465  size_t item_size1second=CYCLUS_SHA1_SIZE;
16466  size_t total_item_size0=item_size1first+item_size1second;
16467  unsigned int count0=0;
16468  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16469  hasher_.Clear();
16470  hasher_.Update(val0.second);
16471  Digest key1second = hasher_.digest();
16472  hid_t keysds1second = VLDataset(VL_STRING, true);
16473  hid_t valsds1second = VLDataset(VL_STRING, false);
16474  if (vlkeys_[VL_STRING].count(key1second) != 1) {
16475  AppendVLKey(keysds1second, VL_STRING, key1second);
16476  InsertVLVal(valsds1second, VL_STRING, key1second, val0.second);
16477  }
16478  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
16479 }
16480 template<>
16481 void Hdf5Back::WriteToBuf<PAIR_INT_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16482  std::pair<int, cyclus::Blob> val0=a->cast<std::pair<int, cyclus::Blob>>();
16483  size_t item_size0=((sizeof(int)+CYCLUS_SHA1_SIZE));
16484  size_t item_size1first=sizeof(int);
16485  size_t item_size1second=CYCLUS_SHA1_SIZE;
16486  size_t total_item_size0=item_size1first+item_size1second;
16487  unsigned int count0=0;
16488  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16489  hasher_.Clear();
16490  hasher_.Update(val0.second);
16491  Digest key1second = hasher_.digest();
16492  hid_t keysds1second = VLDataset(BLOB, true);
16493  hid_t valsds1second = VLDataset(BLOB, false);
16494  if (vlkeys_[BLOB].count(key1second) != 1) {
16495  AppendVLKey(keysds1second, BLOB, key1second);
16496  InsertVLVal(valsds1second, BLOB, key1second, (val0.second).str());
16497  }
16498  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
16499 }
16500 template<>
16501 void Hdf5Back::WriteToBuf<PAIR_INT_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16502  std::pair<int, boost::uuids::uuid> val0=a->cast<std::pair<int, boost::uuids::uuid>>();
16503  size_t item_size0=((sizeof(int)+CYCLUS_UUID_SIZE));
16504  size_t item_size1first=sizeof(int);
16505  size_t item_size1second=CYCLUS_UUID_SIZE;
16506  size_t total_item_size0=item_size1first+item_size1second;
16507  unsigned int count0=0;
16508  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
16509  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16510 }
16511 template<>
16512 void Hdf5Back::WriteToBuf<PAIR_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16513  std::pair<std::string, bool> val0=a->cast<std::pair<std::string, bool>>();
16514  size_t item_size0=((shape[1]+sizeof(char)));
16515  size_t item_size1first=shape[1];
16516  size_t valuelen1first;
16517  size_t item_size1second=sizeof(char);
16518  size_t total_item_size0=item_size1first+item_size1second;
16519  unsigned int count0=0;
16520  valuelen1first=std::min(val0.first.size(), item_size1first);
16521  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16522  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16523  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16524 }
16525 template<>
16526 void Hdf5Back::WriteToBuf<PAIR_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16527  std::pair<std::string, int> val0=a->cast<std::pair<std::string, int>>();
16528  size_t item_size0=((shape[1]+sizeof(int)));
16529  size_t item_size1first=shape[1];
16530  size_t valuelen1first;
16531  size_t item_size1second=sizeof(int);
16532  size_t total_item_size0=item_size1first+item_size1second;
16533  unsigned int count0=0;
16534  valuelen1first=std::min(val0.first.size(), item_size1first);
16535  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16536  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16537  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16538 }
16539 template<>
16540 void Hdf5Back::WriteToBuf<PAIR_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16541  std::pair<std::string, float> val0=a->cast<std::pair<std::string, float>>();
16542  size_t item_size0=((shape[1]+sizeof(float)));
16543  size_t item_size1first=shape[1];
16544  size_t valuelen1first;
16545  size_t item_size1second=sizeof(float);
16546  size_t total_item_size0=item_size1first+item_size1second;
16547  unsigned int count0=0;
16548  valuelen1first=std::min(val0.first.size(), item_size1first);
16549  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16550  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16551  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16552 }
16553 template<>
16554 void Hdf5Back::WriteToBuf<PAIR_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16555  std::pair<std::string, double> val0=a->cast<std::pair<std::string, double>>();
16556  size_t item_size0=((shape[1]+sizeof(double)));
16557  size_t item_size1first=shape[1];
16558  size_t valuelen1first;
16559  size_t item_size1second=sizeof(double);
16560  size_t total_item_size0=item_size1first+item_size1second;
16561  unsigned int count0=0;
16562  valuelen1first=std::min(val0.first.size(), item_size1first);
16563  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16564  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16565  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16566 }
16567 template<>
16568 void Hdf5Back::WriteToBuf<PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16569  std::pair<std::string, std::string> val0=a->cast<std::pair<std::string, std::string>>();
16570  size_t item_size0=((shape[1]+shape[2]));
16571  size_t item_size1first=shape[1];
16572  size_t valuelen1first;
16573  size_t item_size1second=shape[2];
16574  size_t valuelen1second;
16575  size_t total_item_size0=item_size1first+item_size1second;
16576  unsigned int count0=0;
16577  valuelen1first=std::min(val0.first.size(), item_size1first);
16578  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16579  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16580  valuelen1second=std::min(val0.second.size(), item_size1second);
16581  memcpy(buf+(count0*total_item_size0)+0+item_size1first, val0.second.c_str(), valuelen1second);
16582  memset(buf+(count0*total_item_size0)+0+item_size1first+valuelen1second, 0, item_size1second-valuelen1second);
16583 }
16584 template<>
16585 void Hdf5Back::WriteToBuf<PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16586  std::pair<std::string, std::string> val0=a->cast<std::pair<std::string, std::string>>();
16587  size_t item_size0=((shape[1]+CYCLUS_SHA1_SIZE));
16588  size_t item_size1first=shape[1];
16589  size_t valuelen1first;
16590  size_t item_size1second=CYCLUS_SHA1_SIZE;
16591  size_t total_item_size0=item_size1first+item_size1second;
16592  unsigned int count0=0;
16593  valuelen1first=std::min(val0.first.size(), item_size1first);
16594  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16595  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16596  hasher_.Clear();
16597  hasher_.Update(val0.second);
16598  Digest key1second = hasher_.digest();
16599  hid_t keysds1second = VLDataset(VL_STRING, true);
16600  hid_t valsds1second = VLDataset(VL_STRING, false);
16601  if (vlkeys_[VL_STRING].count(key1second) != 1) {
16602  AppendVLKey(keysds1second, VL_STRING, key1second);
16603  InsertVLVal(valsds1second, VL_STRING, key1second, val0.second);
16604  }
16605  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
16606 }
16607 template<>
16608 void Hdf5Back::WriteToBuf<PAIR_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16609  std::pair<std::string, cyclus::Blob> val0=a->cast<std::pair<std::string, cyclus::Blob>>();
16610  size_t item_size0=((shape[1]+CYCLUS_SHA1_SIZE));
16611  size_t item_size1first=shape[1];
16612  size_t valuelen1first;
16613  size_t item_size1second=CYCLUS_SHA1_SIZE;
16614  size_t total_item_size0=item_size1first+item_size1second;
16615  unsigned int count0=0;
16616  valuelen1first=std::min(val0.first.size(), item_size1first);
16617  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16618  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16619  hasher_.Clear();
16620  hasher_.Update(val0.second);
16621  Digest key1second = hasher_.digest();
16622  hid_t keysds1second = VLDataset(BLOB, true);
16623  hid_t valsds1second = VLDataset(BLOB, false);
16624  if (vlkeys_[BLOB].count(key1second) != 1) {
16625  AppendVLKey(keysds1second, BLOB, key1second);
16626  InsertVLVal(valsds1second, BLOB, key1second, (val0.second).str());
16627  }
16628  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
16629 }
16630 template<>
16631 void Hdf5Back::WriteToBuf<PAIR_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16632  std::pair<std::string, boost::uuids::uuid> val0=a->cast<std::pair<std::string, boost::uuids::uuid>>();
16633  size_t item_size0=((shape[1]+CYCLUS_UUID_SIZE));
16634  size_t item_size1first=shape[1];
16635  size_t valuelen1first;
16636  size_t item_size1second=CYCLUS_UUID_SIZE;
16637  size_t total_item_size0=item_size1first+item_size1second;
16638  unsigned int count0=0;
16639  valuelen1first=std::min(val0.first.size(), item_size1first);
16640  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
16641  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
16642  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16643 }
16644 template<>
16645 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16646  std::pair<std::string, bool> val0=a->cast<std::pair<std::string, bool>>();
16647  size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(char)));
16648  size_t item_size1first=CYCLUS_SHA1_SIZE;
16649  size_t item_size1second=sizeof(char);
16650  size_t total_item_size0=item_size1first+item_size1second;
16651  unsigned int count0=0;
16652  hasher_.Clear();
16653  hasher_.Update(val0.first);
16654  Digest key1first = hasher_.digest();
16655  hid_t keysds1first = VLDataset(VL_STRING, true);
16656  hid_t valsds1first = VLDataset(VL_STRING, false);
16657  if (vlkeys_[VL_STRING].count(key1first) != 1) {
16658  AppendVLKey(keysds1first, VL_STRING, key1first);
16659  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16660  }
16661  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
16662  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16663 }
16664 template<>
16665 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16666  std::pair<std::string, int> val0=a->cast<std::pair<std::string, int>>();
16667  size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(int)));
16668  size_t item_size1first=CYCLUS_SHA1_SIZE;
16669  size_t item_size1second=sizeof(int);
16670  size_t total_item_size0=item_size1first+item_size1second;
16671  unsigned int count0=0;
16672  hasher_.Clear();
16673  hasher_.Update(val0.first);
16674  Digest key1first = hasher_.digest();
16675  hid_t keysds1first = VLDataset(VL_STRING, true);
16676  hid_t valsds1first = VLDataset(VL_STRING, false);
16677  if (vlkeys_[VL_STRING].count(key1first) != 1) {
16678  AppendVLKey(keysds1first, VL_STRING, key1first);
16679  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16680  }
16681  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
16682  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16683 }
16684 template<>
16685 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16686  std::pair<std::string, float> val0=a->cast<std::pair<std::string, float>>();
16687  size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(float)));
16688  size_t item_size1first=CYCLUS_SHA1_SIZE;
16689  size_t item_size1second=sizeof(float);
16690  size_t total_item_size0=item_size1first+item_size1second;
16691  unsigned int count0=0;
16692  hasher_.Clear();
16693  hasher_.Update(val0.first);
16694  Digest key1first = hasher_.digest();
16695  hid_t keysds1first = VLDataset(VL_STRING, true);
16696  hid_t valsds1first = VLDataset(VL_STRING, false);
16697  if (vlkeys_[VL_STRING].count(key1first) != 1) {
16698  AppendVLKey(keysds1first, VL_STRING, key1first);
16699  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16700  }
16701  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
16702  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16703 }
16704 template<>
16705 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16706  std::pair<std::string, double> val0=a->cast<std::pair<std::string, double>>();
16707  size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(double)));
16708  size_t item_size1first=CYCLUS_SHA1_SIZE;
16709  size_t item_size1second=sizeof(double);
16710  size_t total_item_size0=item_size1first+item_size1second;
16711  unsigned int count0=0;
16712  hasher_.Clear();
16713  hasher_.Update(val0.first);
16714  Digest key1first = hasher_.digest();
16715  hid_t keysds1first = VLDataset(VL_STRING, true);
16716  hid_t valsds1first = VLDataset(VL_STRING, false);
16717  if (vlkeys_[VL_STRING].count(key1first) != 1) {
16718  AppendVLKey(keysds1first, VL_STRING, key1first);
16719  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16720  }
16721  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
16722  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16723 }
16724 template<>
16725 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16726  std::pair<std::string, std::string> val0=a->cast<std::pair<std::string, std::string>>();
16727  size_t item_size0=((CYCLUS_SHA1_SIZE+shape[2]));
16728  size_t item_size1first=CYCLUS_SHA1_SIZE;
16729  size_t item_size1second=shape[2];
16730  size_t valuelen1second;
16731  size_t total_item_size0=item_size1first+item_size1second;
16732  unsigned int count0=0;
16733  hasher_.Clear();
16734  hasher_.Update(val0.first);
16735  Digest key1first = hasher_.digest();
16736  hid_t keysds1first = VLDataset(VL_STRING, true);
16737  hid_t valsds1first = VLDataset(VL_STRING, false);
16738  if (vlkeys_[VL_STRING].count(key1first) != 1) {
16739  AppendVLKey(keysds1first, VL_STRING, key1first);
16740  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16741  }
16742  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
16743  valuelen1second=std::min(val0.second.size(), item_size1second);
16744  memcpy(buf+(count0*total_item_size0)+0+item_size1first, val0.second.c_str(), valuelen1second);
16745  memset(buf+(count0*total_item_size0)+0+item_size1first+valuelen1second, 0, item_size1second-valuelen1second);
16746 }
16747 template<>
16748 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16749  std::pair<std::string, std::string> val0=a->cast<std::pair<std::string, std::string>>();
16750  size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
16751  size_t item_size1first=CYCLUS_SHA1_SIZE;
16752  size_t item_size1second=CYCLUS_SHA1_SIZE;
16753  size_t total_item_size0=item_size1first+item_size1second;
16754  unsigned int count0=0;
16755  hasher_.Clear();
16756  hasher_.Update(val0.first);
16757  Digest key1first = hasher_.digest();
16758  hid_t keysds1first = VLDataset(VL_STRING, true);
16759  hid_t valsds1first = VLDataset(VL_STRING, false);
16760  if (vlkeys_[VL_STRING].count(key1first) != 1) {
16761  AppendVLKey(keysds1first, VL_STRING, key1first);
16762  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16763  }
16764  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
16765  hasher_.Clear();
16766  hasher_.Update(val0.second);
16767  Digest key1second = hasher_.digest();
16768  hid_t keysds1second = VLDataset(VL_STRING, true);
16769  hid_t valsds1second = VLDataset(VL_STRING, false);
16770  if (vlkeys_[VL_STRING].count(key1second) != 1) {
16771  AppendVLKey(keysds1second, VL_STRING, key1second);
16772  InsertVLVal(valsds1second, VL_STRING, key1second, val0.second);
16773  }
16774  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
16775 }
16776 template<>
16777 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16778  std::pair<std::string, cyclus::Blob> val0=a->cast<std::pair<std::string, cyclus::Blob>>();
16779  size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
16780  size_t item_size1first=CYCLUS_SHA1_SIZE;
16781  size_t item_size1second=CYCLUS_SHA1_SIZE;
16782  size_t total_item_size0=item_size1first+item_size1second;
16783  unsigned int count0=0;
16784  hasher_.Clear();
16785  hasher_.Update(val0.first);
16786  Digest key1first = hasher_.digest();
16787  hid_t keysds1first = VLDataset(VL_STRING, true);
16788  hid_t valsds1first = VLDataset(VL_STRING, false);
16789  if (vlkeys_[VL_STRING].count(key1first) != 1) {
16790  AppendVLKey(keysds1first, VL_STRING, key1first);
16791  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16792  }
16793  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
16794  hasher_.Clear();
16795  hasher_.Update(val0.second);
16796  Digest key1second = hasher_.digest();
16797  hid_t keysds1second = VLDataset(BLOB, true);
16798  hid_t valsds1second = VLDataset(BLOB, false);
16799  if (vlkeys_[BLOB].count(key1second) != 1) {
16800  AppendVLKey(keysds1second, BLOB, key1second);
16801  InsertVLVal(valsds1second, BLOB, key1second, (val0.second).str());
16802  }
16803  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
16804 }
16805 template<>
16806 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16807  std::pair<std::string, boost::uuids::uuid> val0=a->cast<std::pair<std::string, boost::uuids::uuid>>();
16808  size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE));
16809  size_t item_size1first=CYCLUS_SHA1_SIZE;
16810  size_t item_size1second=CYCLUS_UUID_SIZE;
16811  size_t total_item_size0=item_size1first+item_size1second;
16812  unsigned int count0=0;
16813  hasher_.Clear();
16814  hasher_.Update(val0.first);
16815  Digest key1first = hasher_.digest();
16816  hid_t keysds1first = VLDataset(VL_STRING, true);
16817  hid_t valsds1first = VLDataset(VL_STRING, false);
16818  if (vlkeys_[VL_STRING].count(key1first) != 1) {
16819  AppendVLKey(keysds1first, VL_STRING, key1first);
16820  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
16821  }
16822  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
16823  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
16824 }
16825 template<>
16826 void Hdf5Back::WriteToBuf<MAP_INT_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16827  std::map<int, bool> val0=a->cast<std::map<int, bool>>();
16828  size_t item_size0=((sizeof(int)+sizeof(char))*shape[0]);
16829  size_t length0=shape[0];
16830  size_t item_size1key=sizeof(int);
16831  size_t item_size1val=sizeof(char);
16832  size_t total_item_size0=item_size1key+item_size1val;
16833  if(total_item_size0*val0.size()>column){
16834  std::map<int, bool>::iterator eraseit=val0.begin();
16835  std::advance(eraseit, column/total_item_size0);
16836  val0.erase(eraseit,val0.end());
16837 
16838  }
16839  unsigned int count0=0;
16840  std::map<int, bool>::iterator it0=val0.begin();
16841  for(;it0!=val0.end();++it0){
16842  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
16843  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
16844  ++count0;
16845 
16846  }
16847  if(total_item_size0*length0<column){
16848  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16849 
16850  }
16851 }
16852 template<>
16853 void Hdf5Back::WriteToBuf<VL_MAP_INT_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16854  std::map<int, bool> val0=a->cast<std::map<int, bool>>();
16855  size_t item_size0=(CYCLUS_SHA1_SIZE);
16856  size_t item_size1key=sizeof(int);
16857  size_t item_size1val=sizeof(char);
16858  size_t total_item_size0=item_size1key+item_size1val;
16859  hasher_.Clear();
16860  hasher_.Update(val0);
16861  Digest key0 = hasher_.digest();
16862  hid_t keysds0 = VLDataset(VL_MAP_INT_BOOL, true);
16863  hid_t valsds0 = VLDataset(VL_MAP_INT_BOOL, false);
16864  if (vlkeys_[VL_MAP_INT_BOOL].count(key0) != 1) {
16865  hvl_t buf0 = VLValToBuf(val0);
16866  AppendVLKey(keysds0, VL_MAP_INT_BOOL, key0);
16867  InsertVLVal(valsds0, VL_MAP_INT_BOOL, key0, buf0);
16868  }
16869  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16870 }
16871 template<>
16872 void Hdf5Back::WriteToBuf<MAP_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16873  std::map<int, int> val0=a->cast<std::map<int, int>>();
16874  size_t item_size0=((sizeof(int)+sizeof(int))*shape[0]);
16875  size_t length0=shape[0];
16876  size_t item_size1key=sizeof(int);
16877  size_t item_size1val=sizeof(int);
16878  size_t total_item_size0=item_size1key+item_size1val;
16879  if(total_item_size0*val0.size()>column){
16880  std::map<int, int>::iterator eraseit=val0.begin();
16881  std::advance(eraseit, column/total_item_size0);
16882  val0.erase(eraseit,val0.end());
16883 
16884  }
16885  unsigned int count0=0;
16886  std::map<int, int>::iterator it0=val0.begin();
16887  for(;it0!=val0.end();++it0){
16888  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
16889  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
16890  ++count0;
16891 
16892  }
16893  if(total_item_size0*length0<column){
16894  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16895 
16896  }
16897 }
16898 template<>
16899 void Hdf5Back::WriteToBuf<VL_MAP_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16900  std::map<int, int> val0=a->cast<std::map<int, int>>();
16901  size_t item_size0=(CYCLUS_SHA1_SIZE);
16902  size_t item_size1key=sizeof(int);
16903  size_t item_size1val=sizeof(int);
16904  size_t total_item_size0=item_size1key+item_size1val;
16905  hasher_.Clear();
16906  hasher_.Update(val0);
16907  Digest key0 = hasher_.digest();
16908  hid_t keysds0 = VLDataset(VL_MAP_INT_INT, true);
16909  hid_t valsds0 = VLDataset(VL_MAP_INT_INT, false);
16910  if (vlkeys_[VL_MAP_INT_INT].count(key0) != 1) {
16911  hvl_t buf0 = VLValToBuf(val0);
16912  AppendVLKey(keysds0, VL_MAP_INT_INT, key0);
16913  InsertVLVal(valsds0, VL_MAP_INT_INT, key0, buf0);
16914  }
16915  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16916 }
16917 template<>
16918 void Hdf5Back::WriteToBuf<MAP_INT_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16919  std::map<int, float> val0=a->cast<std::map<int, float>>();
16920  size_t item_size0=((sizeof(int)+sizeof(float))*shape[0]);
16921  size_t length0=shape[0];
16922  size_t item_size1key=sizeof(int);
16923  size_t item_size1val=sizeof(float);
16924  size_t total_item_size0=item_size1key+item_size1val;
16925  if(total_item_size0*val0.size()>column){
16926  std::map<int, float>::iterator eraseit=val0.begin();
16927  std::advance(eraseit, column/total_item_size0);
16928  val0.erase(eraseit,val0.end());
16929 
16930  }
16931  unsigned int count0=0;
16932  std::map<int, float>::iterator it0=val0.begin();
16933  for(;it0!=val0.end();++it0){
16934  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
16935  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
16936  ++count0;
16937 
16938  }
16939  if(total_item_size0*length0<column){
16940  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16941 
16942  }
16943 }
16944 template<>
16945 void Hdf5Back::WriteToBuf<VL_MAP_INT_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16946  std::map<int, float> val0=a->cast<std::map<int, float>>();
16947  size_t item_size0=(CYCLUS_SHA1_SIZE);
16948  size_t item_size1key=sizeof(int);
16949  size_t item_size1val=sizeof(float);
16950  size_t total_item_size0=item_size1key+item_size1val;
16951  hasher_.Clear();
16952  hasher_.Update(val0);
16953  Digest key0 = hasher_.digest();
16954  hid_t keysds0 = VLDataset(VL_MAP_INT_FLOAT, true);
16955  hid_t valsds0 = VLDataset(VL_MAP_INT_FLOAT, false);
16956  if (vlkeys_[VL_MAP_INT_FLOAT].count(key0) != 1) {
16957  hvl_t buf0 = VLValToBuf(val0);
16958  AppendVLKey(keysds0, VL_MAP_INT_FLOAT, key0);
16959  InsertVLVal(valsds0, VL_MAP_INT_FLOAT, key0, buf0);
16960  }
16961  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
16962 }
16963 template<>
16964 void Hdf5Back::WriteToBuf<MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16965  std::map<int, double> val0=a->cast<std::map<int, double>>();
16966  size_t item_size0=((sizeof(int)+sizeof(double))*shape[0]);
16967  size_t length0=shape[0];
16968  size_t item_size1key=sizeof(int);
16969  size_t item_size1val=sizeof(double);
16970  size_t total_item_size0=item_size1key+item_size1val;
16971  if(total_item_size0*val0.size()>column){
16972  std::map<int, double>::iterator eraseit=val0.begin();
16973  std::advance(eraseit, column/total_item_size0);
16974  val0.erase(eraseit,val0.end());
16975 
16976  }
16977  unsigned int count0=0;
16978  std::map<int, double>::iterator it0=val0.begin();
16979  for(;it0!=val0.end();++it0){
16980  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
16981  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
16982  ++count0;
16983 
16984  }
16985  if(total_item_size0*length0<column){
16986  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
16987 
16988  }
16989 }
16990 template<>
16991 void Hdf5Back::WriteToBuf<VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
16992  std::map<int, double> val0=a->cast<std::map<int, double>>();
16993  size_t item_size0=(CYCLUS_SHA1_SIZE);
16994  size_t item_size1key=sizeof(int);
16995  size_t item_size1val=sizeof(double);
16996  size_t total_item_size0=item_size1key+item_size1val;
16997  hasher_.Clear();
16998  hasher_.Update(val0);
16999  Digest key0 = hasher_.digest();
17000  hid_t keysds0 = VLDataset(VL_MAP_INT_DOUBLE, true);
17001  hid_t valsds0 = VLDataset(VL_MAP_INT_DOUBLE, false);
17002  if (vlkeys_[VL_MAP_INT_DOUBLE].count(key0) != 1) {
17003  hvl_t buf0 = VLValToBuf(val0);
17004  AppendVLKey(keysds0, VL_MAP_INT_DOUBLE, key0);
17005  InsertVLVal(valsds0, VL_MAP_INT_DOUBLE, key0, buf0);
17006  }
17007  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17008 }
17009 template<>
17010 void Hdf5Back::WriteToBuf<MAP_INT_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17011  std::map<int, std::string> val0=a->cast<std::map<int, std::string>>();
17012  size_t item_size0=((sizeof(int)+shape[2])*shape[0]);
17013  size_t length0=shape[0];
17014  size_t item_size1key=sizeof(int);
17015  size_t item_size1val=shape[2];
17016  size_t valuelen1val;
17017  size_t total_item_size0=item_size1key+item_size1val;
17018  if(total_item_size0*val0.size()>column){
17019  std::map<int, std::string>::iterator eraseit=val0.begin();
17020  std::advance(eraseit, column/total_item_size0);
17021  val0.erase(eraseit,val0.end());
17022 
17023  }
17024  unsigned int count0=0;
17025  std::map<int, std::string>::iterator it0=val0.begin();
17026  for(;it0!=val0.end();++it0){
17027  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
17028  valuelen1val=std::min(it0->second.size(), item_size1val);
17029  memcpy(buf+(count0*total_item_size0)+0+item_size1key, it0->second.c_str(), valuelen1val);
17030  memset(buf+(count0*total_item_size0)+0+item_size1key+valuelen1val, 0, item_size1val-valuelen1val);
17031  ++count0;
17032 
17033  }
17034  if(total_item_size0*length0<column){
17035  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17036 
17037  }
17038 }
17039 template<>
17040 void Hdf5Back::WriteToBuf<VL_MAP_INT_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17041  std::map<int, std::string> val0=a->cast<std::map<int, std::string>>();
17042  size_t item_size0=(CYCLUS_SHA1_SIZE);
17043  size_t item_size1key=sizeof(int);
17044  size_t item_size1val=shape[2];
17045  size_t valuelen1val;
17046  size_t total_item_size0=item_size1key+item_size1val;
17047  unsigned int count0=0;
17048  std::map<int, std::string>::iterator it0=val0.begin();
17049  std::map<int, std::string> fixed_val0;
17050  unsigned int pad_count0=0;
17051  for(;it0!=val0.end();++it0){
17052  std::string child1val=std::string(it0->second,0,item_size1val);
17053  fixed_val0[it0->first] = child1val;
17054  ++pad_count0;
17055 
17056  }
17057  hasher_.Clear();
17058  hasher_.Update(fixed_val0);
17059  Digest key0 = hasher_.digest();
17060  hid_t keysds0 = VLDataset(VL_MAP_INT_STRING, true);
17061  hid_t valsds0 = VLDataset(VL_MAP_INT_STRING, false);
17062  if (vlkeys_[VL_MAP_INT_STRING].count(key0) != 1) {
17063  hvl_t buf0 = VLValToBuf(fixed_val0);
17064  AppendVLKey(keysds0, VL_MAP_INT_STRING, key0);
17065  InsertVLVal(valsds0, VL_MAP_INT_STRING, key0, buf0);
17066  }
17067  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17068 }
17069 template<>
17070 void Hdf5Back::WriteToBuf<MAP_INT_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17071  std::map<int, std::string> val0=a->cast<std::map<int, std::string>>();
17072  size_t item_size0=((sizeof(int)+CYCLUS_SHA1_SIZE)*shape[0]);
17073  size_t length0=shape[0];
17074  size_t item_size1key=sizeof(int);
17075  size_t item_size1val=CYCLUS_SHA1_SIZE;
17076  size_t total_item_size0=item_size1key+item_size1val;
17077  if(total_item_size0*val0.size()>column){
17078  std::map<int, std::string>::iterator eraseit=val0.begin();
17079  std::advance(eraseit, column/total_item_size0);
17080  val0.erase(eraseit,val0.end());
17081 
17082  }
17083  unsigned int count0=0;
17084  std::map<int, std::string>::iterator it0=val0.begin();
17085  for(;it0!=val0.end();++it0){
17086  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
17087  hasher_.Clear();
17088  hasher_.Update(it0->second);
17089  Digest key1val = hasher_.digest();
17090  hid_t keysds1val = VLDataset(VL_STRING, true);
17091  hid_t valsds1val = VLDataset(VL_STRING, false);
17092  if (vlkeys_[VL_STRING].count(key1val) != 1) {
17093  AppendVLKey(keysds1val, VL_STRING, key1val);
17094  InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
17095  }
17096  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
17097  ++count0;
17098 
17099  }
17100  if(total_item_size0*length0<column){
17101  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17102 
17103  }
17104 }
17105 template<>
17106 void Hdf5Back::WriteToBuf<VL_MAP_INT_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17107  std::map<int, std::string> val0=a->cast<std::map<int, std::string>>();
17108  size_t item_size0=(CYCLUS_SHA1_SIZE);
17109  size_t item_size1key=sizeof(int);
17110  size_t item_size1val=CYCLUS_SHA1_SIZE;
17111  size_t total_item_size0=item_size1key+item_size1val;
17112  hasher_.Clear();
17113  hasher_.Update(val0);
17114  Digest key0 = hasher_.digest();
17115  hid_t keysds0 = VLDataset(VL_MAP_INT_VL_STRING, true);
17116  hid_t valsds0 = VLDataset(VL_MAP_INT_VL_STRING, false);
17117  if (vlkeys_[VL_MAP_INT_VL_STRING].count(key0) != 1) {
17118  hvl_t buf0 = VLValToBuf(val0);
17119  AppendVLKey(keysds0, VL_MAP_INT_VL_STRING, key0);
17120  InsertVLVal(valsds0, VL_MAP_INT_VL_STRING, key0, buf0);
17121  }
17122  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17123 }
17124 template<>
17125 void Hdf5Back::WriteToBuf<MAP_INT_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17126  std::map<int, cyclus::Blob> val0=a->cast<std::map<int, cyclus::Blob>>();
17127  size_t item_size0=((sizeof(int)+CYCLUS_SHA1_SIZE)*shape[0]);
17128  size_t length0=shape[0];
17129  size_t item_size1key=sizeof(int);
17130  size_t item_size1val=CYCLUS_SHA1_SIZE;
17131  size_t total_item_size0=item_size1key+item_size1val;
17132  if(total_item_size0*val0.size()>column){
17133  std::map<int, cyclus::Blob>::iterator eraseit=val0.begin();
17134  std::advance(eraseit, column/total_item_size0);
17135  val0.erase(eraseit,val0.end());
17136 
17137  }
17138  unsigned int count0=0;
17139  std::map<int, cyclus::Blob>::iterator it0=val0.begin();
17140  for(;it0!=val0.end();++it0){
17141  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
17142  hasher_.Clear();
17143  hasher_.Update(it0->second);
17144  Digest key1val = hasher_.digest();
17145  hid_t keysds1val = VLDataset(BLOB, true);
17146  hid_t valsds1val = VLDataset(BLOB, false);
17147  if (vlkeys_[BLOB].count(key1val) != 1) {
17148  AppendVLKey(keysds1val, BLOB, key1val);
17149  InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
17150  }
17151  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
17152  ++count0;
17153 
17154  }
17155  if(total_item_size0*length0<column){
17156  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17157 
17158  }
17159 }
17160 template<>
17161 void Hdf5Back::WriteToBuf<VL_MAP_INT_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17162  std::map<int, cyclus::Blob> val0=a->cast<std::map<int, cyclus::Blob>>();
17163  size_t item_size0=(CYCLUS_SHA1_SIZE);
17164  size_t item_size1key=sizeof(int);
17165  size_t item_size1val=CYCLUS_SHA1_SIZE;
17166  size_t total_item_size0=item_size1key+item_size1val;
17167  hasher_.Clear();
17168  hasher_.Update(val0);
17169  Digest key0 = hasher_.digest();
17170  hid_t keysds0 = VLDataset(VL_MAP_INT_BLOB, true);
17171  hid_t valsds0 = VLDataset(VL_MAP_INT_BLOB, false);
17172  if (vlkeys_[VL_MAP_INT_BLOB].count(key0) != 1) {
17173  hvl_t buf0 = VLValToBuf(val0);
17174  AppendVLKey(keysds0, VL_MAP_INT_BLOB, key0);
17175  InsertVLVal(valsds0, VL_MAP_INT_BLOB, key0, buf0);
17176  }
17177  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17178 }
17179 template<>
17180 void Hdf5Back::WriteToBuf<MAP_INT_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17181  std::map<int, boost::uuids::uuid> val0=a->cast<std::map<int, boost::uuids::uuid>>();
17182  size_t item_size0=((sizeof(int)+CYCLUS_UUID_SIZE)*shape[0]);
17183  size_t length0=shape[0];
17184  size_t item_size1key=sizeof(int);
17185  size_t item_size1val=CYCLUS_UUID_SIZE;
17186  size_t total_item_size0=item_size1key+item_size1val;
17187  if(total_item_size0*val0.size()>column){
17188  std::map<int, boost::uuids::uuid>::iterator eraseit=val0.begin();
17189  std::advance(eraseit, column/total_item_size0);
17190  val0.erase(eraseit,val0.end());
17191 
17192  }
17193  unsigned int count0=0;
17194  std::map<int, boost::uuids::uuid>::iterator it0=val0.begin();
17195  for(;it0!=val0.end();++it0){
17196  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
17197  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17198  ++count0;
17199 
17200  }
17201  if(total_item_size0*length0<column){
17202  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17203 
17204  }
17205 }
17206 template<>
17207 void Hdf5Back::WriteToBuf<VL_MAP_INT_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17208  std::map<int, boost::uuids::uuid> val0=a->cast<std::map<int, boost::uuids::uuid>>();
17209  size_t item_size0=(CYCLUS_SHA1_SIZE);
17210  size_t item_size1key=sizeof(int);
17211  size_t item_size1val=CYCLUS_UUID_SIZE;
17212  size_t total_item_size0=item_size1key+item_size1val;
17213  hasher_.Clear();
17214  hasher_.Update(val0);
17215  Digest key0 = hasher_.digest();
17216  hid_t keysds0 = VLDataset(VL_MAP_INT_UUID, true);
17217  hid_t valsds0 = VLDataset(VL_MAP_INT_UUID, false);
17218  if (vlkeys_[VL_MAP_INT_UUID].count(key0) != 1) {
17219  hvl_t buf0 = VLValToBuf(val0);
17220  AppendVLKey(keysds0, VL_MAP_INT_UUID, key0);
17221  InsertVLVal(valsds0, VL_MAP_INT_UUID, key0, buf0);
17222  }
17223  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17224 }
17225 template<>
17226 void Hdf5Back::WriteToBuf<MAP_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17227  std::map<std::string, bool> val0=a->cast<std::map<std::string, bool>>();
17228  size_t item_size0=((shape[1]+sizeof(char))*shape[0]);
17229  size_t length0=shape[0];
17230  size_t item_size1key=shape[1];
17231  size_t valuelen1key;
17232  size_t item_size1val=sizeof(char);
17233  size_t total_item_size0=item_size1key+item_size1val;
17234  if(total_item_size0*val0.size()>column){
17235  std::map<std::string, bool>::iterator eraseit=val0.begin();
17236  std::advance(eraseit, column/total_item_size0);
17237  val0.erase(eraseit,val0.end());
17238 
17239  }
17240  unsigned int count0=0;
17241  std::map<std::string, bool>::iterator it0=val0.begin();
17242  for(;it0!=val0.end();++it0){
17243  valuelen1key=std::min(it0->first.size(), item_size1key);
17244  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17245  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17246  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17247  ++count0;
17248 
17249  }
17250  if(total_item_size0*length0<column){
17251  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17252 
17253  }
17254 }
17255 template<>
17256 void Hdf5Back::WriteToBuf<VL_MAP_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17257  std::map<std::string, bool> val0=a->cast<std::map<std::string, bool>>();
17258  size_t item_size0=(CYCLUS_SHA1_SIZE);
17259  size_t item_size1key=shape[1];
17260  size_t valuelen1key;
17261  size_t item_size1val=sizeof(char);
17262  size_t total_item_size0=item_size1key+item_size1val;
17263  unsigned int count0=0;
17264  std::map<std::string, bool>::iterator it0=val0.begin();
17265  std::map<std::string, bool> fixed_val0;
17266  unsigned int pad_count0=0;
17267  for(;it0!=val0.end();++it0){
17268  std::string child1key=std::string(it0->first,0,item_size1key);
17269  fixed_val0[child1key] = it0->second;
17270  ++pad_count0;
17271 
17272  }
17273  hasher_.Clear();
17274  hasher_.Update(fixed_val0);
17275  Digest key0 = hasher_.digest();
17276  hid_t keysds0 = VLDataset(VL_MAP_STRING_BOOL, true);
17277  hid_t valsds0 = VLDataset(VL_MAP_STRING_BOOL, false);
17278  if (vlkeys_[VL_MAP_STRING_BOOL].count(key0) != 1) {
17279  hvl_t buf0 = VLValToBuf(fixed_val0);
17280  AppendVLKey(keysds0, VL_MAP_STRING_BOOL, key0);
17281  InsertVLVal(valsds0, VL_MAP_STRING_BOOL, key0, buf0);
17282  }
17283  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17284 }
17285 template<>
17286 void Hdf5Back::WriteToBuf<MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17287  std::map<std::string, int> val0=a->cast<std::map<std::string, int>>();
17288  size_t item_size0=((shape[1]+sizeof(int))*shape[0]);
17289  size_t length0=shape[0];
17290  size_t item_size1key=shape[1];
17291  size_t valuelen1key;
17292  size_t item_size1val=sizeof(int);
17293  size_t total_item_size0=item_size1key+item_size1val;
17294  if(total_item_size0*val0.size()>column){
17295  std::map<std::string, int>::iterator eraseit=val0.begin();
17296  std::advance(eraseit, column/total_item_size0);
17297  val0.erase(eraseit,val0.end());
17298 
17299  }
17300  unsigned int count0=0;
17301  std::map<std::string, int>::iterator it0=val0.begin();
17302  for(;it0!=val0.end();++it0){
17303  valuelen1key=std::min(it0->first.size(), item_size1key);
17304  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17305  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17306  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17307  ++count0;
17308 
17309  }
17310  if(total_item_size0*length0<column){
17311  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17312 
17313  }
17314 }
17315 template<>
17316 void Hdf5Back::WriteToBuf<VL_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17317  std::map<std::string, int> val0=a->cast<std::map<std::string, int>>();
17318  size_t item_size0=(CYCLUS_SHA1_SIZE);
17319  size_t item_size1key=shape[1];
17320  size_t valuelen1key;
17321  size_t item_size1val=sizeof(int);
17322  size_t total_item_size0=item_size1key+item_size1val;
17323  unsigned int count0=0;
17324  std::map<std::string, int>::iterator it0=val0.begin();
17325  std::map<std::string, int> fixed_val0;
17326  unsigned int pad_count0=0;
17327  for(;it0!=val0.end();++it0){
17328  std::string child1key=std::string(it0->first,0,item_size1key);
17329  fixed_val0[child1key] = it0->second;
17330  ++pad_count0;
17331 
17332  }
17333  hasher_.Clear();
17334  hasher_.Update(fixed_val0);
17335  Digest key0 = hasher_.digest();
17336  hid_t keysds0 = VLDataset(VL_MAP_STRING_INT, true);
17337  hid_t valsds0 = VLDataset(VL_MAP_STRING_INT, false);
17338  if (vlkeys_[VL_MAP_STRING_INT].count(key0) != 1) {
17339  hvl_t buf0 = VLValToBuf(fixed_val0);
17340  AppendVLKey(keysds0, VL_MAP_STRING_INT, key0);
17341  InsertVLVal(valsds0, VL_MAP_STRING_INT, key0, buf0);
17342  }
17343  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17344 }
17345 template<>
17346 void Hdf5Back::WriteToBuf<MAP_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17347  std::map<std::string, float> val0=a->cast<std::map<std::string, float>>();
17348  size_t item_size0=((shape[1]+sizeof(float))*shape[0]);
17349  size_t length0=shape[0];
17350  size_t item_size1key=shape[1];
17351  size_t valuelen1key;
17352  size_t item_size1val=sizeof(float);
17353  size_t total_item_size0=item_size1key+item_size1val;
17354  if(total_item_size0*val0.size()>column){
17355  std::map<std::string, float>::iterator eraseit=val0.begin();
17356  std::advance(eraseit, column/total_item_size0);
17357  val0.erase(eraseit,val0.end());
17358 
17359  }
17360  unsigned int count0=0;
17361  std::map<std::string, float>::iterator it0=val0.begin();
17362  for(;it0!=val0.end();++it0){
17363  valuelen1key=std::min(it0->first.size(), item_size1key);
17364  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17365  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17366  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17367  ++count0;
17368 
17369  }
17370  if(total_item_size0*length0<column){
17371  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17372 
17373  }
17374 }
17375 template<>
17376 void Hdf5Back::WriteToBuf<VL_MAP_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17377  std::map<std::string, float> val0=a->cast<std::map<std::string, float>>();
17378  size_t item_size0=(CYCLUS_SHA1_SIZE);
17379  size_t item_size1key=shape[1];
17380  size_t valuelen1key;
17381  size_t item_size1val=sizeof(float);
17382  size_t total_item_size0=item_size1key+item_size1val;
17383  unsigned int count0=0;
17384  std::map<std::string, float>::iterator it0=val0.begin();
17385  std::map<std::string, float> fixed_val0;
17386  unsigned int pad_count0=0;
17387  for(;it0!=val0.end();++it0){
17388  std::string child1key=std::string(it0->first,0,item_size1key);
17389  fixed_val0[child1key] = it0->second;
17390  ++pad_count0;
17391 
17392  }
17393  hasher_.Clear();
17394  hasher_.Update(fixed_val0);
17395  Digest key0 = hasher_.digest();
17396  hid_t keysds0 = VLDataset(VL_MAP_STRING_FLOAT, true);
17397  hid_t valsds0 = VLDataset(VL_MAP_STRING_FLOAT, false);
17398  if (vlkeys_[VL_MAP_STRING_FLOAT].count(key0) != 1) {
17399  hvl_t buf0 = VLValToBuf(fixed_val0);
17400  AppendVLKey(keysds0, VL_MAP_STRING_FLOAT, key0);
17401  InsertVLVal(valsds0, VL_MAP_STRING_FLOAT, key0, buf0);
17402  }
17403  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17404 }
17405 template<>
17406 void Hdf5Back::WriteToBuf<MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17407  std::map<std::string, double> val0=a->cast<std::map<std::string, double>>();
17408  size_t item_size0=((shape[1]+sizeof(double))*shape[0]);
17409  size_t length0=shape[0];
17410  size_t item_size1key=shape[1];
17411  size_t valuelen1key;
17412  size_t item_size1val=sizeof(double);
17413  size_t total_item_size0=item_size1key+item_size1val;
17414  if(total_item_size0*val0.size()>column){
17415  std::map<std::string, double>::iterator eraseit=val0.begin();
17416  std::advance(eraseit, column/total_item_size0);
17417  val0.erase(eraseit,val0.end());
17418 
17419  }
17420  unsigned int count0=0;
17421  std::map<std::string, double>::iterator it0=val0.begin();
17422  for(;it0!=val0.end();++it0){
17423  valuelen1key=std::min(it0->first.size(), item_size1key);
17424  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17425  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17426  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17427  ++count0;
17428 
17429  }
17430  if(total_item_size0*length0<column){
17431  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17432 
17433  }
17434 }
17435 template<>
17436 void Hdf5Back::WriteToBuf<VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17437  std::map<std::string, double> val0=a->cast<std::map<std::string, double>>();
17438  size_t item_size0=(CYCLUS_SHA1_SIZE);
17439  size_t item_size1key=shape[1];
17440  size_t valuelen1key;
17441  size_t item_size1val=sizeof(double);
17442  size_t total_item_size0=item_size1key+item_size1val;
17443  unsigned int count0=0;
17444  std::map<std::string, double>::iterator it0=val0.begin();
17445  std::map<std::string, double> fixed_val0;
17446  unsigned int pad_count0=0;
17447  for(;it0!=val0.end();++it0){
17448  std::string child1key=std::string(it0->first,0,item_size1key);
17449  fixed_val0[child1key] = it0->second;
17450  ++pad_count0;
17451 
17452  }
17453  hasher_.Clear();
17454  hasher_.Update(fixed_val0);
17455  Digest key0 = hasher_.digest();
17456  hid_t keysds0 = VLDataset(VL_MAP_STRING_DOUBLE, true);
17457  hid_t valsds0 = VLDataset(VL_MAP_STRING_DOUBLE, false);
17458  if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key0) != 1) {
17459  hvl_t buf0 = VLValToBuf(fixed_val0);
17460  AppendVLKey(keysds0, VL_MAP_STRING_DOUBLE, key0);
17461  InsertVLVal(valsds0, VL_MAP_STRING_DOUBLE, key0, buf0);
17462  }
17463  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17464 }
17465 template<>
17466 void Hdf5Back::WriteToBuf<MAP_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17467  std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17468  size_t item_size0=((shape[1]+shape[2])*shape[0]);
17469  size_t length0=shape[0];
17470  size_t item_size1key=shape[1];
17471  size_t valuelen1key;
17472  size_t item_size1val=shape[2];
17473  size_t valuelen1val;
17474  size_t total_item_size0=item_size1key+item_size1val;
17475  if(total_item_size0*val0.size()>column){
17476  std::map<std::string, std::string>::iterator eraseit=val0.begin();
17477  std::advance(eraseit, column/total_item_size0);
17478  val0.erase(eraseit,val0.end());
17479 
17480  }
17481  unsigned int count0=0;
17482  std::map<std::string, std::string>::iterator it0=val0.begin();
17483  for(;it0!=val0.end();++it0){
17484  valuelen1key=std::min(it0->first.size(), item_size1key);
17485  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17486  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17487  valuelen1val=std::min(it0->second.size(), item_size1val);
17488  memcpy(buf+(count0*total_item_size0)+0+item_size1key, it0->second.c_str(), valuelen1val);
17489  memset(buf+(count0*total_item_size0)+0+item_size1key+valuelen1val, 0, item_size1val-valuelen1val);
17490  ++count0;
17491 
17492  }
17493  if(total_item_size0*length0<column){
17494  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17495 
17496  }
17497 }
17498 template<>
17499 void Hdf5Back::WriteToBuf<VL_MAP_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17500  std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17501  size_t item_size0=(CYCLUS_SHA1_SIZE);
17502  size_t item_size1key=shape[1];
17503  size_t valuelen1key;
17504  size_t item_size1val=shape[2];
17505  size_t valuelen1val;
17506  size_t total_item_size0=item_size1key+item_size1val;
17507  unsigned int count0=0;
17508  std::map<std::string, std::string>::iterator it0=val0.begin();
17509  std::map<std::string, std::string> fixed_val0;
17510  unsigned int pad_count0=0;
17511  for(;it0!=val0.end();++it0){
17512  std::string child1key=std::string(it0->first,0,item_size1key);
17513  std::string child1val=std::string(it0->second,0,item_size1val);
17514  fixed_val0[child1key] = child1val;
17515  ++pad_count0;
17516 
17517  }
17518  hasher_.Clear();
17519  hasher_.Update(fixed_val0);
17520  Digest key0 = hasher_.digest();
17521  hid_t keysds0 = VLDataset(VL_MAP_STRING_STRING, true);
17522  hid_t valsds0 = VLDataset(VL_MAP_STRING_STRING, false);
17523  if (vlkeys_[VL_MAP_STRING_STRING].count(key0) != 1) {
17524  hvl_t buf0 = VLValToBuf(fixed_val0);
17525  AppendVLKey(keysds0, VL_MAP_STRING_STRING, key0);
17526  InsertVLVal(valsds0, VL_MAP_STRING_STRING, key0, buf0);
17527  }
17528  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17529 }
17530 template<>
17531 void Hdf5Back::WriteToBuf<MAP_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17532  std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17533  size_t item_size0=((shape[1]+CYCLUS_SHA1_SIZE)*shape[0]);
17534  size_t length0=shape[0];
17535  size_t item_size1key=shape[1];
17536  size_t valuelen1key;
17537  size_t item_size1val=CYCLUS_SHA1_SIZE;
17538  size_t total_item_size0=item_size1key+item_size1val;
17539  if(total_item_size0*val0.size()>column){
17540  std::map<std::string, std::string>::iterator eraseit=val0.begin();
17541  std::advance(eraseit, column/total_item_size0);
17542  val0.erase(eraseit,val0.end());
17543 
17544  }
17545  unsigned int count0=0;
17546  std::map<std::string, std::string>::iterator it0=val0.begin();
17547  for(;it0!=val0.end();++it0){
17548  valuelen1key=std::min(it0->first.size(), item_size1key);
17549  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17550  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17551  hasher_.Clear();
17552  hasher_.Update(it0->second);
17553  Digest key1val = hasher_.digest();
17554  hid_t keysds1val = VLDataset(VL_STRING, true);
17555  hid_t valsds1val = VLDataset(VL_STRING, false);
17556  if (vlkeys_[VL_STRING].count(key1val) != 1) {
17557  AppendVLKey(keysds1val, VL_STRING, key1val);
17558  InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
17559  }
17560  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
17561  ++count0;
17562 
17563  }
17564  if(total_item_size0*length0<column){
17565  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17566 
17567  }
17568 }
17569 template<>
17570 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17571  std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17572  size_t item_size0=(CYCLUS_SHA1_SIZE);
17573  size_t item_size1key=shape[1];
17574  size_t valuelen1key;
17575  size_t item_size1val=CYCLUS_SHA1_SIZE;
17576  size_t total_item_size0=item_size1key+item_size1val;
17577  unsigned int count0=0;
17578  std::map<std::string, std::string>::iterator it0=val0.begin();
17579  std::map<std::string, std::string> fixed_val0;
17580  unsigned int pad_count0=0;
17581  for(;it0!=val0.end();++it0){
17582  std::string child1key=std::string(it0->first,0,item_size1key);
17583  fixed_val0[child1key] = it0->second;
17584  ++pad_count0;
17585 
17586  }
17587  hasher_.Clear();
17588  hasher_.Update(fixed_val0);
17589  Digest key0 = hasher_.digest();
17590  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_STRING, true);
17591  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_STRING, false);
17592  if (vlkeys_[VL_MAP_STRING_VL_STRING].count(key0) != 1) {
17593  hvl_t buf0 = VLValToBuf(fixed_val0);
17594  AppendVLKey(keysds0, VL_MAP_STRING_VL_STRING, key0);
17595  InsertVLVal(valsds0, VL_MAP_STRING_VL_STRING, key0, buf0);
17596  }
17597  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17598 }
17599 template<>
17600 void Hdf5Back::WriteToBuf<MAP_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17601  std::map<std::string, cyclus::Blob> val0=a->cast<std::map<std::string, cyclus::Blob>>();
17602  size_t item_size0=((shape[1]+CYCLUS_SHA1_SIZE)*shape[0]);
17603  size_t length0=shape[0];
17604  size_t item_size1key=shape[1];
17605  size_t valuelen1key;
17606  size_t item_size1val=CYCLUS_SHA1_SIZE;
17607  size_t total_item_size0=item_size1key+item_size1val;
17608  if(total_item_size0*val0.size()>column){
17609  std::map<std::string, cyclus::Blob>::iterator eraseit=val0.begin();
17610  std::advance(eraseit, column/total_item_size0);
17611  val0.erase(eraseit,val0.end());
17612 
17613  }
17614  unsigned int count0=0;
17615  std::map<std::string, cyclus::Blob>::iterator it0=val0.begin();
17616  for(;it0!=val0.end();++it0){
17617  valuelen1key=std::min(it0->first.size(), item_size1key);
17618  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17619  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17620  hasher_.Clear();
17621  hasher_.Update(it0->second);
17622  Digest key1val = hasher_.digest();
17623  hid_t keysds1val = VLDataset(BLOB, true);
17624  hid_t valsds1val = VLDataset(BLOB, false);
17625  if (vlkeys_[BLOB].count(key1val) != 1) {
17626  AppendVLKey(keysds1val, BLOB, key1val);
17627  InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
17628  }
17629  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
17630  ++count0;
17631 
17632  }
17633  if(total_item_size0*length0<column){
17634  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17635 
17636  }
17637 }
17638 template<>
17639 void Hdf5Back::WriteToBuf<VL_MAP_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17640  std::map<std::string, cyclus::Blob> val0=a->cast<std::map<std::string, cyclus::Blob>>();
17641  size_t item_size0=(CYCLUS_SHA1_SIZE);
17642  size_t item_size1key=shape[1];
17643  size_t valuelen1key;
17644  size_t item_size1val=CYCLUS_SHA1_SIZE;
17645  size_t total_item_size0=item_size1key+item_size1val;
17646  unsigned int count0=0;
17647  std::map<std::string, cyclus::Blob>::iterator it0=val0.begin();
17648  std::map<std::string, cyclus::Blob> fixed_val0;
17649  unsigned int pad_count0=0;
17650  for(;it0!=val0.end();++it0){
17651  std::string child1key=std::string(it0->first,0,item_size1key);
17652  fixed_val0[child1key] = it0->second;
17653  ++pad_count0;
17654 
17655  }
17656  hasher_.Clear();
17657  hasher_.Update(fixed_val0);
17658  Digest key0 = hasher_.digest();
17659  hid_t keysds0 = VLDataset(VL_MAP_STRING_BLOB, true);
17660  hid_t valsds0 = VLDataset(VL_MAP_STRING_BLOB, false);
17661  if (vlkeys_[VL_MAP_STRING_BLOB].count(key0) != 1) {
17662  hvl_t buf0 = VLValToBuf(fixed_val0);
17663  AppendVLKey(keysds0, VL_MAP_STRING_BLOB, key0);
17664  InsertVLVal(valsds0, VL_MAP_STRING_BLOB, key0, buf0);
17665  }
17666  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17667 }
17668 template<>
17669 void Hdf5Back::WriteToBuf<MAP_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17670  std::map<std::string, boost::uuids::uuid> val0=a->cast<std::map<std::string, boost::uuids::uuid>>();
17671  size_t item_size0=((shape[1]+CYCLUS_UUID_SIZE)*shape[0]);
17672  size_t length0=shape[0];
17673  size_t item_size1key=shape[1];
17674  size_t valuelen1key;
17675  size_t item_size1val=CYCLUS_UUID_SIZE;
17676  size_t total_item_size0=item_size1key+item_size1val;
17677  if(total_item_size0*val0.size()>column){
17678  std::map<std::string, boost::uuids::uuid>::iterator eraseit=val0.begin();
17679  std::advance(eraseit, column/total_item_size0);
17680  val0.erase(eraseit,val0.end());
17681 
17682  }
17683  unsigned int count0=0;
17684  std::map<std::string, boost::uuids::uuid>::iterator it0=val0.begin();
17685  for(;it0!=val0.end();++it0){
17686  valuelen1key=std::min(it0->first.size(), item_size1key);
17687  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
17688  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
17689  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17690  ++count0;
17691 
17692  }
17693  if(total_item_size0*length0<column){
17694  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17695 
17696  }
17697 }
17698 template<>
17699 void Hdf5Back::WriteToBuf<VL_MAP_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17700  std::map<std::string, boost::uuids::uuid> val0=a->cast<std::map<std::string, boost::uuids::uuid>>();
17701  size_t item_size0=(CYCLUS_SHA1_SIZE);
17702  size_t item_size1key=shape[1];
17703  size_t valuelen1key;
17704  size_t item_size1val=CYCLUS_UUID_SIZE;
17705  size_t total_item_size0=item_size1key+item_size1val;
17706  unsigned int count0=0;
17707  std::map<std::string, boost::uuids::uuid>::iterator it0=val0.begin();
17708  std::map<std::string, boost::uuids::uuid> fixed_val0;
17709  unsigned int pad_count0=0;
17710  for(;it0!=val0.end();++it0){
17711  std::string child1key=std::string(it0->first,0,item_size1key);
17712  fixed_val0[child1key] = it0->second;
17713  ++pad_count0;
17714 
17715  }
17716  hasher_.Clear();
17717  hasher_.Update(fixed_val0);
17718  Digest key0 = hasher_.digest();
17719  hid_t keysds0 = VLDataset(VL_MAP_STRING_UUID, true);
17720  hid_t valsds0 = VLDataset(VL_MAP_STRING_UUID, false);
17721  if (vlkeys_[VL_MAP_STRING_UUID].count(key0) != 1) {
17722  hvl_t buf0 = VLValToBuf(fixed_val0);
17723  AppendVLKey(keysds0, VL_MAP_STRING_UUID, key0);
17724  InsertVLVal(valsds0, VL_MAP_STRING_UUID, key0, buf0);
17725  }
17726  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17727 }
17728 template<>
17729 void Hdf5Back::WriteToBuf<MAP_VL_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17730  std::map<std::string, bool> val0=a->cast<std::map<std::string, bool>>();
17731  size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(char))*shape[0]);
17732  size_t length0=shape[0];
17733  size_t item_size1key=CYCLUS_SHA1_SIZE;
17734  size_t item_size1val=sizeof(char);
17735  size_t total_item_size0=item_size1key+item_size1val;
17736  if(total_item_size0*val0.size()>column){
17737  std::map<std::string, bool>::iterator eraseit=val0.begin();
17738  std::advance(eraseit, column/total_item_size0);
17739  val0.erase(eraseit,val0.end());
17740 
17741  }
17742  unsigned int count0=0;
17743  std::map<std::string, bool>::iterator it0=val0.begin();
17744  for(;it0!=val0.end();++it0){
17745  hasher_.Clear();
17746  hasher_.Update(it0->first);
17747  Digest key1key = hasher_.digest();
17748  hid_t keysds1key = VLDataset(VL_STRING, true);
17749  hid_t valsds1key = VLDataset(VL_STRING, false);
17750  if (vlkeys_[VL_STRING].count(key1key) != 1) {
17751  AppendVLKey(keysds1key, VL_STRING, key1key);
17752  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17753  }
17754  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
17755  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17756  ++count0;
17757 
17758  }
17759  if(total_item_size0*length0<column){
17760  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17761 
17762  }
17763 }
17764 template<>
17765 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_BOOL>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17766  std::map<std::string, bool> val0=a->cast<std::map<std::string, bool>>();
17767  size_t item_size0=(CYCLUS_SHA1_SIZE);
17768  size_t item_size1key=CYCLUS_SHA1_SIZE;
17769  size_t item_size1val=sizeof(char);
17770  size_t total_item_size0=item_size1key+item_size1val;
17771  hasher_.Clear();
17772  hasher_.Update(val0);
17773  Digest key0 = hasher_.digest();
17774  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_BOOL, true);
17775  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_BOOL, false);
17776  if (vlkeys_[VL_MAP_VL_STRING_BOOL].count(key0) != 1) {
17777  hvl_t buf0 = VLValToBuf(val0);
17778  AppendVLKey(keysds0, VL_MAP_VL_STRING_BOOL, key0);
17779  InsertVLVal(valsds0, VL_MAP_VL_STRING_BOOL, key0, buf0);
17780  }
17781  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17782 }
17783 template<>
17784 void Hdf5Back::WriteToBuf<MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17785  std::map<std::string, int> val0=a->cast<std::map<std::string, int>>();
17786  size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[0]);
17787  size_t length0=shape[0];
17788  size_t item_size1key=CYCLUS_SHA1_SIZE;
17789  size_t item_size1val=sizeof(int);
17790  size_t total_item_size0=item_size1key+item_size1val;
17791  if(total_item_size0*val0.size()>column){
17792  std::map<std::string, int>::iterator eraseit=val0.begin();
17793  std::advance(eraseit, column/total_item_size0);
17794  val0.erase(eraseit,val0.end());
17795 
17796  }
17797  unsigned int count0=0;
17798  std::map<std::string, int>::iterator it0=val0.begin();
17799  for(;it0!=val0.end();++it0){
17800  hasher_.Clear();
17801  hasher_.Update(it0->first);
17802  Digest key1key = hasher_.digest();
17803  hid_t keysds1key = VLDataset(VL_STRING, true);
17804  hid_t valsds1key = VLDataset(VL_STRING, false);
17805  if (vlkeys_[VL_STRING].count(key1key) != 1) {
17806  AppendVLKey(keysds1key, VL_STRING, key1key);
17807  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17808  }
17809  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
17810  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17811  ++count0;
17812 
17813  }
17814  if(total_item_size0*length0<column){
17815  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17816 
17817  }
17818 }
17819 template<>
17820 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17821  std::map<std::string, int> val0=a->cast<std::map<std::string, int>>();
17822  size_t item_size0=(CYCLUS_SHA1_SIZE);
17823  size_t item_size1key=CYCLUS_SHA1_SIZE;
17824  size_t item_size1val=sizeof(int);
17825  size_t total_item_size0=item_size1key+item_size1val;
17826  hasher_.Clear();
17827  hasher_.Update(val0);
17828  Digest key0 = hasher_.digest();
17829  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_INT, true);
17830  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_INT, false);
17831  if (vlkeys_[VL_MAP_VL_STRING_INT].count(key0) != 1) {
17832  hvl_t buf0 = VLValToBuf(val0);
17833  AppendVLKey(keysds0, VL_MAP_VL_STRING_INT, key0);
17834  InsertVLVal(valsds0, VL_MAP_VL_STRING_INT, key0, buf0);
17835  }
17836  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17837 }
17838 template<>
17839 void Hdf5Back::WriteToBuf<MAP_VL_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17840  std::map<std::string, float> val0=a->cast<std::map<std::string, float>>();
17841  size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(float))*shape[0]);
17842  size_t length0=shape[0];
17843  size_t item_size1key=CYCLUS_SHA1_SIZE;
17844  size_t item_size1val=sizeof(float);
17845  size_t total_item_size0=item_size1key+item_size1val;
17846  if(total_item_size0*val0.size()>column){
17847  std::map<std::string, float>::iterator eraseit=val0.begin();
17848  std::advance(eraseit, column/total_item_size0);
17849  val0.erase(eraseit,val0.end());
17850 
17851  }
17852  unsigned int count0=0;
17853  std::map<std::string, float>::iterator it0=val0.begin();
17854  for(;it0!=val0.end();++it0){
17855  hasher_.Clear();
17856  hasher_.Update(it0->first);
17857  Digest key1key = hasher_.digest();
17858  hid_t keysds1key = VLDataset(VL_STRING, true);
17859  hid_t valsds1key = VLDataset(VL_STRING, false);
17860  if (vlkeys_[VL_STRING].count(key1key) != 1) {
17861  AppendVLKey(keysds1key, VL_STRING, key1key);
17862  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17863  }
17864  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
17865  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17866  ++count0;
17867 
17868  }
17869  if(total_item_size0*length0<column){
17870  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17871 
17872  }
17873 }
17874 template<>
17875 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_FLOAT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17876  std::map<std::string, float> val0=a->cast<std::map<std::string, float>>();
17877  size_t item_size0=(CYCLUS_SHA1_SIZE);
17878  size_t item_size1key=CYCLUS_SHA1_SIZE;
17879  size_t item_size1val=sizeof(float);
17880  size_t total_item_size0=item_size1key+item_size1val;
17881  hasher_.Clear();
17882  hasher_.Update(val0);
17883  Digest key0 = hasher_.digest();
17884  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_FLOAT, true);
17885  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_FLOAT, false);
17886  if (vlkeys_[VL_MAP_VL_STRING_FLOAT].count(key0) != 1) {
17887  hvl_t buf0 = VLValToBuf(val0);
17888  AppendVLKey(keysds0, VL_MAP_VL_STRING_FLOAT, key0);
17889  InsertVLVal(valsds0, VL_MAP_VL_STRING_FLOAT, key0, buf0);
17890  }
17891  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17892 }
17893 template<>
17894 void Hdf5Back::WriteToBuf<MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17895  std::map<std::string, double> val0=a->cast<std::map<std::string, double>>();
17896  size_t item_size0=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[0]);
17897  size_t length0=shape[0];
17898  size_t item_size1key=CYCLUS_SHA1_SIZE;
17899  size_t item_size1val=sizeof(double);
17900  size_t total_item_size0=item_size1key+item_size1val;
17901  if(total_item_size0*val0.size()>column){
17902  std::map<std::string, double>::iterator eraseit=val0.begin();
17903  std::advance(eraseit, column/total_item_size0);
17904  val0.erase(eraseit,val0.end());
17905 
17906  }
17907  unsigned int count0=0;
17908  std::map<std::string, double>::iterator it0=val0.begin();
17909  for(;it0!=val0.end();++it0){
17910  hasher_.Clear();
17911  hasher_.Update(it0->first);
17912  Digest key1key = hasher_.digest();
17913  hid_t keysds1key = VLDataset(VL_STRING, true);
17914  hid_t valsds1key = VLDataset(VL_STRING, false);
17915  if (vlkeys_[VL_STRING].count(key1key) != 1) {
17916  AppendVLKey(keysds1key, VL_STRING, key1key);
17917  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17918  }
17919  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
17920  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
17921  ++count0;
17922 
17923  }
17924  if(total_item_size0*length0<column){
17925  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17926 
17927  }
17928 }
17929 template<>
17930 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17931  std::map<std::string, double> val0=a->cast<std::map<std::string, double>>();
17932  size_t item_size0=(CYCLUS_SHA1_SIZE);
17933  size_t item_size1key=CYCLUS_SHA1_SIZE;
17934  size_t item_size1val=sizeof(double);
17935  size_t total_item_size0=item_size1key+item_size1val;
17936  hasher_.Clear();
17937  hasher_.Update(val0);
17938  Digest key0 = hasher_.digest();
17939  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
17940  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
17941  if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
17942  hvl_t buf0 = VLValToBuf(val0);
17943  AppendVLKey(keysds0, VL_MAP_VL_STRING_DOUBLE, key0);
17944  InsertVLVal(valsds0, VL_MAP_VL_STRING_DOUBLE, key0, buf0);
17945  }
17946  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
17947 }
17948 template<>
17949 void Hdf5Back::WriteToBuf<MAP_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17950  std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17951  size_t item_size0=((CYCLUS_SHA1_SIZE+shape[2])*shape[0]);
17952  size_t length0=shape[0];
17953  size_t item_size1key=CYCLUS_SHA1_SIZE;
17954  size_t item_size1val=shape[2];
17955  size_t valuelen1val;
17956  size_t total_item_size0=item_size1key+item_size1val;
17957  if(total_item_size0*val0.size()>column){
17958  std::map<std::string, std::string>::iterator eraseit=val0.begin();
17959  std::advance(eraseit, column/total_item_size0);
17960  val0.erase(eraseit,val0.end());
17961 
17962  }
17963  unsigned int count0=0;
17964  std::map<std::string, std::string>::iterator it0=val0.begin();
17965  for(;it0!=val0.end();++it0){
17966  hasher_.Clear();
17967  hasher_.Update(it0->first);
17968  Digest key1key = hasher_.digest();
17969  hid_t keysds1key = VLDataset(VL_STRING, true);
17970  hid_t valsds1key = VLDataset(VL_STRING, false);
17971  if (vlkeys_[VL_STRING].count(key1key) != 1) {
17972  AppendVLKey(keysds1key, VL_STRING, key1key);
17973  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
17974  }
17975  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
17976  valuelen1val=std::min(it0->second.size(), item_size1val);
17977  memcpy(buf+(count0*total_item_size0)+0+item_size1key, it0->second.c_str(), valuelen1val);
17978  memset(buf+(count0*total_item_size0)+0+item_size1key+valuelen1val, 0, item_size1val-valuelen1val);
17979  ++count0;
17980 
17981  }
17982  if(total_item_size0*length0<column){
17983  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
17984 
17985  }
17986 }
17987 template<>
17988 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
17989  std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
17990  size_t item_size0=(CYCLUS_SHA1_SIZE);
17991  size_t item_size1key=CYCLUS_SHA1_SIZE;
17992  size_t item_size1val=shape[2];
17993  size_t valuelen1val;
17994  size_t total_item_size0=item_size1key+item_size1val;
17995  unsigned int count0=0;
17996  std::map<std::string, std::string>::iterator it0=val0.begin();
17997  std::map<std::string, std::string> fixed_val0;
17998  unsigned int pad_count0=0;
17999  for(;it0!=val0.end();++it0){
18000  std::string child1val=std::string(it0->second,0,item_size1val);
18001  fixed_val0[it0->first] = child1val;
18002  ++pad_count0;
18003 
18004  }
18005  hasher_.Clear();
18006  hasher_.Update(fixed_val0);
18007  Digest key0 = hasher_.digest();
18008  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_STRING, true);
18009  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_STRING, false);
18010  if (vlkeys_[VL_MAP_VL_STRING_STRING].count(key0) != 1) {
18011  hvl_t buf0 = VLValToBuf(fixed_val0);
18012  AppendVLKey(keysds0, VL_MAP_VL_STRING_STRING, key0);
18013  InsertVLVal(valsds0, VL_MAP_VL_STRING_STRING, key0, buf0);
18014  }
18015  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18016 }
18017 template<>
18018 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18019  std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
18020  size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)*shape[0]);
18021  size_t length0=shape[0];
18022  size_t item_size1key=CYCLUS_SHA1_SIZE;
18023  size_t item_size1val=CYCLUS_SHA1_SIZE;
18024  size_t total_item_size0=item_size1key+item_size1val;
18025  if(total_item_size0*val0.size()>column){
18026  std::map<std::string, std::string>::iterator eraseit=val0.begin();
18027  std::advance(eraseit, column/total_item_size0);
18028  val0.erase(eraseit,val0.end());
18029 
18030  }
18031  unsigned int count0=0;
18032  std::map<std::string, std::string>::iterator it0=val0.begin();
18033  for(;it0!=val0.end();++it0){
18034  hasher_.Clear();
18035  hasher_.Update(it0->first);
18036  Digest key1key = hasher_.digest();
18037  hid_t keysds1key = VLDataset(VL_STRING, true);
18038  hid_t valsds1key = VLDataset(VL_STRING, false);
18039  if (vlkeys_[VL_STRING].count(key1key) != 1) {
18040  AppendVLKey(keysds1key, VL_STRING, key1key);
18041  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18042  }
18043  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
18044  hasher_.Clear();
18045  hasher_.Update(it0->second);
18046  Digest key1val = hasher_.digest();
18047  hid_t keysds1val = VLDataset(VL_STRING, true);
18048  hid_t valsds1val = VLDataset(VL_STRING, false);
18049  if (vlkeys_[VL_STRING].count(key1val) != 1) {
18050  AppendVLKey(keysds1val, VL_STRING, key1val);
18051  InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
18052  }
18053  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
18054  ++count0;
18055 
18056  }
18057  if(total_item_size0*length0<column){
18058  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18059 
18060  }
18061 }
18062 template<>
18063 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18064  std::map<std::string, std::string> val0=a->cast<std::map<std::string, std::string>>();
18065  size_t item_size0=(CYCLUS_SHA1_SIZE);
18066  size_t item_size1key=CYCLUS_SHA1_SIZE;
18067  size_t item_size1val=CYCLUS_SHA1_SIZE;
18068  size_t total_item_size0=item_size1key+item_size1val;
18069  hasher_.Clear();
18070  hasher_.Update(val0);
18071  Digest key0 = hasher_.digest();
18072  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_STRING, true);
18073  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_STRING, false);
18074  if (vlkeys_[VL_MAP_VL_STRING_VL_STRING].count(key0) != 1) {
18075  hvl_t buf0 = VLValToBuf(val0);
18076  AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_STRING, key0);
18077  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_STRING, key0, buf0);
18078  }
18079  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18080 }
18081 template<>
18082 void Hdf5Back::WriteToBuf<MAP_VL_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18083  std::map<std::string, cyclus::Blob> val0=a->cast<std::map<std::string, cyclus::Blob>>();
18084  size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)*shape[0]);
18085  size_t length0=shape[0];
18086  size_t item_size1key=CYCLUS_SHA1_SIZE;
18087  size_t item_size1val=CYCLUS_SHA1_SIZE;
18088  size_t total_item_size0=item_size1key+item_size1val;
18089  if(total_item_size0*val0.size()>column){
18090  std::map<std::string, cyclus::Blob>::iterator eraseit=val0.begin();
18091  std::advance(eraseit, column/total_item_size0);
18092  val0.erase(eraseit,val0.end());
18093 
18094  }
18095  unsigned int count0=0;
18096  std::map<std::string, cyclus::Blob>::iterator it0=val0.begin();
18097  for(;it0!=val0.end();++it0){
18098  hasher_.Clear();
18099  hasher_.Update(it0->first);
18100  Digest key1key = hasher_.digest();
18101  hid_t keysds1key = VLDataset(VL_STRING, true);
18102  hid_t valsds1key = VLDataset(VL_STRING, false);
18103  if (vlkeys_[VL_STRING].count(key1key) != 1) {
18104  AppendVLKey(keysds1key, VL_STRING, key1key);
18105  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18106  }
18107  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
18108  hasher_.Clear();
18109  hasher_.Update(it0->second);
18110  Digest key1val = hasher_.digest();
18111  hid_t keysds1val = VLDataset(BLOB, true);
18112  hid_t valsds1val = VLDataset(BLOB, false);
18113  if (vlkeys_[BLOB].count(key1val) != 1) {
18114  AppendVLKey(keysds1val, BLOB, key1val);
18115  InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
18116  }
18117  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
18118  ++count0;
18119 
18120  }
18121  if(total_item_size0*length0<column){
18122  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18123 
18124  }
18125 }
18126 template<>
18127 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_BLOB>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18128  std::map<std::string, cyclus::Blob> val0=a->cast<std::map<std::string, cyclus::Blob>>();
18129  size_t item_size0=(CYCLUS_SHA1_SIZE);
18130  size_t item_size1key=CYCLUS_SHA1_SIZE;
18131  size_t item_size1val=CYCLUS_SHA1_SIZE;
18132  size_t total_item_size0=item_size1key+item_size1val;
18133  hasher_.Clear();
18134  hasher_.Update(val0);
18135  Digest key0 = hasher_.digest();
18136  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_BLOB, true);
18137  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_BLOB, false);
18138  if (vlkeys_[VL_MAP_VL_STRING_BLOB].count(key0) != 1) {
18139  hvl_t buf0 = VLValToBuf(val0);
18140  AppendVLKey(keysds0, VL_MAP_VL_STRING_BLOB, key0);
18141  InsertVLVal(valsds0, VL_MAP_VL_STRING_BLOB, key0, buf0);
18142  }
18143  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18144 }
18145 template<>
18146 void Hdf5Back::WriteToBuf<MAP_VL_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18147  std::map<std::string, boost::uuids::uuid> val0=a->cast<std::map<std::string, boost::uuids::uuid>>();
18148  size_t item_size0=((CYCLUS_SHA1_SIZE+CYCLUS_UUID_SIZE)*shape[0]);
18149  size_t length0=shape[0];
18150  size_t item_size1key=CYCLUS_SHA1_SIZE;
18151  size_t item_size1val=CYCLUS_UUID_SIZE;
18152  size_t total_item_size0=item_size1key+item_size1val;
18153  if(total_item_size0*val0.size()>column){
18154  std::map<std::string, boost::uuids::uuid>::iterator eraseit=val0.begin();
18155  std::advance(eraseit, column/total_item_size0);
18156  val0.erase(eraseit,val0.end());
18157 
18158  }
18159  unsigned int count0=0;
18160  std::map<std::string, boost::uuids::uuid>::iterator it0=val0.begin();
18161  for(;it0!=val0.end();++it0){
18162  hasher_.Clear();
18163  hasher_.Update(it0->first);
18164  Digest key1key = hasher_.digest();
18165  hid_t keysds1key = VLDataset(VL_STRING, true);
18166  hid_t valsds1key = VLDataset(VL_STRING, false);
18167  if (vlkeys_[VL_STRING].count(key1key) != 1) {
18168  AppendVLKey(keysds1key, VL_STRING, key1key);
18169  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18170  }
18171  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
18172  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
18173  ++count0;
18174 
18175  }
18176  if(total_item_size0*length0<column){
18177  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18178 
18179  }
18180 }
18181 template<>
18182 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_UUID>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18183  std::map<std::string, boost::uuids::uuid> val0=a->cast<std::map<std::string, boost::uuids::uuid>>();
18184  size_t item_size0=(CYCLUS_SHA1_SIZE);
18185  size_t item_size1key=CYCLUS_SHA1_SIZE;
18186  size_t item_size1val=CYCLUS_UUID_SIZE;
18187  size_t total_item_size0=item_size1key+item_size1val;
18188  hasher_.Clear();
18189  hasher_.Update(val0);
18190  Digest key0 = hasher_.digest();
18191  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_UUID, true);
18192  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_UUID, false);
18193  if (vlkeys_[VL_MAP_VL_STRING_UUID].count(key0) != 1) {
18194  hvl_t buf0 = VLValToBuf(val0);
18195  AppendVLKey(keysds0, VL_MAP_VL_STRING_UUID, key0);
18196  InsertVLVal(valsds0, VL_MAP_VL_STRING_UUID, key0, buf0);
18197  }
18198  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18199 }
18200 template<>
18201 void Hdf5Back::WriteToBuf<MAP_PAIR_INT_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18202  std::map<std::pair<int, std::string>, double> val0=a->cast<std::map<std::pair<int, std::string>, double>>();
18203  size_t item_size0=((((sizeof(int)+shape[3]))+sizeof(double))*shape[0]);
18204  size_t length0=shape[0];
18205  size_t item_size1key=((sizeof(int)+shape[3]));
18206  size_t item_size2keyfirst=sizeof(int);
18207  size_t item_size2keysecond=shape[3];
18208  size_t valuelen2keysecond;
18209  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
18210  size_t item_size1val=sizeof(double);
18211  size_t total_item_size0=item_size1key+item_size1val;
18212  if(total_item_size0*val0.size()>column){
18213  std::map<std::pair<int, std::string>, double>::iterator eraseit=val0.begin();
18214  std::advance(eraseit, column/total_item_size0);
18215  val0.erase(eraseit,val0.end());
18216 
18217  }
18218  unsigned int count0=0;
18219  std::map<std::pair<int, std::string>, double>::iterator it0=val0.begin();
18220  for(;it0!=val0.end();++it0){
18221  unsigned int count1key=0;
18222  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, &(it0->first.first), item_size2keyfirst);
18223  valuelen2keysecond=std::min(it0->first.second.size(), item_size2keysecond);
18224  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, it0->first.second.c_str(), valuelen2keysecond);
18225  memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst+valuelen2keysecond, 0, item_size2keysecond-valuelen2keysecond);
18226  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
18227  ++count0;
18228 
18229  }
18230  if(total_item_size0*length0<column){
18231  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18232 
18233  }
18234 }
18235 template<>
18236 void Hdf5Back::WriteToBuf<VL_MAP_PAIR_INT_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18237  std::map<std::pair<int, std::string>, double> val0=a->cast<std::map<std::pair<int, std::string>, double>>();
18238  size_t item_size0=(CYCLUS_SHA1_SIZE);
18239  size_t item_size1key=((sizeof(int)+shape[3]));
18240  size_t item_size2keyfirst=sizeof(int);
18241  size_t item_size2keysecond=shape[3];
18242  size_t valuelen2keysecond;
18243  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
18244  size_t item_size1val=sizeof(double);
18245  size_t total_item_size0=item_size1key+item_size1val;
18246  unsigned int count0=0;
18247  std::map<std::pair<int, std::string>, double>::iterator it0=val0.begin();
18248  std::map<std::pair<int, std::string>, double> fixed_val0;
18249  unsigned int pad_count0=0;
18250  for(;it0!=val0.end();++it0){
18251  std::pair<int, std::string> child1key;
18252  unsigned int pad_count1key=0;
18253  std::string child2keysecond=std::string(it0->first.second,0,item_size2keysecond);
18254  child1key = std::make_pair(it0->first.first,child2keysecond);
18255  fixed_val0[child1key] = it0->second;
18256  ++pad_count0;
18257 
18258  }
18259  hasher_.Clear();
18260  hasher_.Update(fixed_val0);
18261  Digest key0 = hasher_.digest();
18262  hid_t keysds0 = VLDataset(VL_MAP_PAIR_INT_STRING_DOUBLE, true);
18263  hid_t valsds0 = VLDataset(VL_MAP_PAIR_INT_STRING_DOUBLE, false);
18264  if (vlkeys_[VL_MAP_PAIR_INT_STRING_DOUBLE].count(key0) != 1) {
18265  hvl_t buf0 = VLValToBuf(fixed_val0);
18266  AppendVLKey(keysds0, VL_MAP_PAIR_INT_STRING_DOUBLE, key0);
18267  InsertVLVal(valsds0, VL_MAP_PAIR_INT_STRING_DOUBLE, key0, buf0);
18268  }
18269  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18270 }
18271 template<>
18272 void Hdf5Back::WriteToBuf<MAP_PAIR_INT_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18273  std::map<std::pair<int, std::string>, double> val0=a->cast<std::map<std::pair<int, std::string>, double>>();
18274  size_t item_size0=((((sizeof(int)+CYCLUS_SHA1_SIZE))+sizeof(double))*shape[0]);
18275  size_t length0=shape[0];
18276  size_t item_size1key=((sizeof(int)+CYCLUS_SHA1_SIZE));
18277  size_t item_size2keyfirst=sizeof(int);
18278  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
18279  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
18280  size_t item_size1val=sizeof(double);
18281  size_t total_item_size0=item_size1key+item_size1val;
18282  if(total_item_size0*val0.size()>column){
18283  std::map<std::pair<int, std::string>, double>::iterator eraseit=val0.begin();
18284  std::advance(eraseit, column/total_item_size0);
18285  val0.erase(eraseit,val0.end());
18286 
18287  }
18288  unsigned int count0=0;
18289  std::map<std::pair<int, std::string>, double>::iterator it0=val0.begin();
18290  for(;it0!=val0.end();++it0){
18291  unsigned int count1key=0;
18292  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, &(it0->first.first), item_size2keyfirst);
18293  hasher_.Clear();
18294  hasher_.Update(it0->first.second);
18295  Digest key2keysecond = hasher_.digest();
18296  hid_t keysds2keysecond = VLDataset(VL_STRING, true);
18297  hid_t valsds2keysecond = VLDataset(VL_STRING, false);
18298  if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
18299  AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
18300  InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
18301  }
18302  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, key2keysecond.val, CYCLUS_SHA1_SIZE);
18303  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
18304  ++count0;
18305 
18306  }
18307  if(total_item_size0*length0<column){
18308  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18309 
18310  }
18311 }
18312 template<>
18313 void Hdf5Back::WriteToBuf<VL_MAP_PAIR_INT_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18314  std::map<std::pair<int, std::string>, double> val0=a->cast<std::map<std::pair<int, std::string>, double>>();
18315  size_t item_size0=(CYCLUS_SHA1_SIZE);
18316  size_t item_size1key=((sizeof(int)+CYCLUS_SHA1_SIZE));
18317  size_t item_size2keyfirst=sizeof(int);
18318  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
18319  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
18320  size_t item_size1val=sizeof(double);
18321  size_t total_item_size0=item_size1key+item_size1val;
18322  hasher_.Clear();
18323  hasher_.Update(val0);
18324  Digest key0 = hasher_.digest();
18325  hid_t keysds0 = VLDataset(VL_MAP_PAIR_INT_VL_STRING_DOUBLE, true);
18326  hid_t valsds0 = VLDataset(VL_MAP_PAIR_INT_VL_STRING_DOUBLE, false);
18327  if (vlkeys_[VL_MAP_PAIR_INT_VL_STRING_DOUBLE].count(key0) != 1) {
18328  hvl_t buf0 = VLValToBuf(val0);
18329  AppendVLKey(keysds0, VL_MAP_PAIR_INT_VL_STRING_DOUBLE, key0);
18330  InsertVLVal(valsds0, VL_MAP_PAIR_INT_VL_STRING_DOUBLE, key0, buf0);
18331  }
18332  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18333 }
18334 template<>
18335 void Hdf5Back::WriteToBuf<MAP_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18336  std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18337  size_t item_size0=((shape[1]+((sizeof(double))*shape[2]))*shape[0]);
18338  size_t length0=shape[0];
18339  size_t item_size1key=shape[1];
18340  size_t valuelen1key;
18341  size_t item_size1val=((sizeof(double))*shape[2]);
18342  size_t length1val=shape[2];
18343  size_t item_size2valelem=sizeof(double);
18344  size_t total_item_size1val=item_size2valelem;
18345  size_t total_item_size0=item_size1key+item_size1val;
18346  if(total_item_size0*val0.size()>column){
18347  std::map<std::string, std::vector<double>>::iterator eraseit=val0.begin();
18348  std::advance(eraseit, column/total_item_size0);
18349  val0.erase(eraseit,val0.end());
18350 
18351  }
18352  unsigned int count0=0;
18353  std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18354  for(;it0!=val0.end();++it0){
18355  valuelen1key=std::min(it0->first.size(), item_size1key);
18356  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18357  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18358  unsigned int count1val=0;
18359  std::vector<double>::iterator it1val=it0->second.begin();
18360  for(;it1val!=it0->second.end();++it1val){
18361  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val, &(*it1val), item_size2valelem);
18362  ++count1val;
18363 
18364  }
18365  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
18366  ++count0;
18367 
18368  }
18369  if(total_item_size0*length0<column){
18370  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18371 
18372  }
18373 }
18374 template<>
18375 void Hdf5Back::WriteToBuf<MAP_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18376  std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18377  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
18378  size_t length0=shape[0];
18379  size_t item_size1key=shape[1];
18380  size_t valuelen1key;
18381  size_t item_size1val=(CYCLUS_SHA1_SIZE);
18382  size_t item_size2valelem=sizeof(double);
18383  size_t total_item_size1val=item_size2valelem;
18384  size_t total_item_size0=item_size1key+item_size1val;
18385  if(total_item_size0*val0.size()>column){
18386  std::map<std::string, std::vector<double>>::iterator eraseit=val0.begin();
18387  std::advance(eraseit, column/total_item_size0);
18388  val0.erase(eraseit,val0.end());
18389 
18390  }
18391  unsigned int count0=0;
18392  std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18393  for(;it0!=val0.end();++it0){
18394  valuelen1key=std::min(it0->first.size(), item_size1key);
18395  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18396  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18397  hasher_.Clear();
18398  hasher_.Update(it0->second);
18399  Digest key1val = hasher_.digest();
18400  hid_t keysds1val = VLDataset(VL_VECTOR_DOUBLE, true);
18401  hid_t valsds1val = VLDataset(VL_VECTOR_DOUBLE, false);
18402  if (vlkeys_[VL_VECTOR_DOUBLE].count(key1val) != 1) {
18403  hvl_t buf1val = VLValToBuf(it0->second);
18404  AppendVLKey(keysds1val, VL_VECTOR_DOUBLE, key1val);
18405  InsertVLVal(valsds1val, VL_VECTOR_DOUBLE, key1val, buf1val);
18406  }
18407  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
18408  ++count0;
18409 
18410  }
18411  if(total_item_size0*length0<column){
18412  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18413 
18414  }
18415 }
18416 template<>
18417 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18418  std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18419  size_t item_size0=(CYCLUS_SHA1_SIZE);
18420  size_t item_size1key=shape[1];
18421  size_t valuelen1key;
18422  size_t item_size1val=((sizeof(double))*shape[2]);
18423  size_t length1val=shape[2];
18424  size_t item_size2valelem=sizeof(double);
18425  size_t total_item_size1val=item_size2valelem;
18426  size_t total_item_size0=item_size1key+item_size1val;
18427  unsigned int count0=0;
18428  std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18429  std::map<std::string, std::vector<double>> fixed_val0;
18430  unsigned int pad_count0=0;
18431  for(;it0!=val0.end();++it0){
18432  std::string child1key=std::string(it0->first,0,item_size1key);
18433  std::vector<double> child1val;
18434  unsigned int pad_count1val=0;
18435  std::vector<double>::iterator it1val=it0->second.begin();
18436  for(;it1val!=it0->second.end();++it1val){
18437  child1val.push_back((*it1val));
18438  ++pad_count1val;
18439 
18440  }
18441  child1val.resize(length1val);
18442  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
18443  fixed_val0[child1key] = child1val;
18444  ++pad_count0;
18445 
18446  }
18447  hasher_.Clear();
18448  hasher_.Update(fixed_val0);
18449  Digest key0 = hasher_.digest();
18450  hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_DOUBLE, true);
18451  hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_DOUBLE, false);
18452  if (vlkeys_[VL_MAP_STRING_VECTOR_DOUBLE].count(key0) != 1) {
18453  hvl_t buf0 = VLValToBuf(fixed_val0);
18454  AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_DOUBLE, key0);
18455  InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_DOUBLE, key0, buf0);
18456  }
18457  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18458 }
18459 template<>
18460 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18461  std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18462  size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2]))*shape[0]);
18463  size_t length0=shape[0];
18464  size_t item_size1key=CYCLUS_SHA1_SIZE;
18465  size_t item_size1val=((sizeof(double))*shape[2]);
18466  size_t length1val=shape[2];
18467  size_t item_size2valelem=sizeof(double);
18468  size_t total_item_size1val=item_size2valelem;
18469  size_t total_item_size0=item_size1key+item_size1val;
18470  if(total_item_size0*val0.size()>column){
18471  std::map<std::string, std::vector<double>>::iterator eraseit=val0.begin();
18472  std::advance(eraseit, column/total_item_size0);
18473  val0.erase(eraseit,val0.end());
18474 
18475  }
18476  unsigned int count0=0;
18477  std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18478  for(;it0!=val0.end();++it0){
18479  hasher_.Clear();
18480  hasher_.Update(it0->first);
18481  Digest key1key = hasher_.digest();
18482  hid_t keysds1key = VLDataset(VL_STRING, true);
18483  hid_t valsds1key = VLDataset(VL_STRING, false);
18484  if (vlkeys_[VL_STRING].count(key1key) != 1) {
18485  AppendVLKey(keysds1key, VL_STRING, key1key);
18486  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18487  }
18488  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
18489  unsigned int count1val=0;
18490  std::vector<double>::iterator it1val=it0->second.begin();
18491  for(;it1val!=it0->second.end();++it1val){
18492  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val, &(*it1val), item_size2valelem);
18493  ++count1val;
18494 
18495  }
18496  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
18497  ++count0;
18498 
18499  }
18500  if(total_item_size0*length0<column){
18501  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18502 
18503  }
18504 }
18505 template<>
18506 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18507  std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18508  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
18509  size_t length0=shape[0];
18510  size_t item_size1key=CYCLUS_SHA1_SIZE;
18511  size_t item_size1val=(CYCLUS_SHA1_SIZE);
18512  size_t item_size2valelem=sizeof(double);
18513  size_t total_item_size1val=item_size2valelem;
18514  size_t total_item_size0=item_size1key+item_size1val;
18515  if(total_item_size0*val0.size()>column){
18516  std::map<std::string, std::vector<double>>::iterator eraseit=val0.begin();
18517  std::advance(eraseit, column/total_item_size0);
18518  val0.erase(eraseit,val0.end());
18519 
18520  }
18521  unsigned int count0=0;
18522  std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18523  for(;it0!=val0.end();++it0){
18524  hasher_.Clear();
18525  hasher_.Update(it0->first);
18526  Digest key1key = hasher_.digest();
18527  hid_t keysds1key = VLDataset(VL_STRING, true);
18528  hid_t valsds1key = VLDataset(VL_STRING, false);
18529  if (vlkeys_[VL_STRING].count(key1key) != 1) {
18530  AppendVLKey(keysds1key, VL_STRING, key1key);
18531  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18532  }
18533  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
18534  hasher_.Clear();
18535  hasher_.Update(it0->second);
18536  Digest key1val = hasher_.digest();
18537  hid_t keysds1val = VLDataset(VL_VECTOR_DOUBLE, true);
18538  hid_t valsds1val = VLDataset(VL_VECTOR_DOUBLE, false);
18539  if (vlkeys_[VL_VECTOR_DOUBLE].count(key1val) != 1) {
18540  hvl_t buf1val = VLValToBuf(it0->second);
18541  AppendVLKey(keysds1val, VL_VECTOR_DOUBLE, key1val);
18542  InsertVLVal(valsds1val, VL_VECTOR_DOUBLE, key1val, buf1val);
18543  }
18544  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
18545  ++count0;
18546 
18547  }
18548  if(total_item_size0*length0<column){
18549  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18550 
18551  }
18552 }
18553 template<>
18554 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18555  std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18556  size_t item_size0=(CYCLUS_SHA1_SIZE);
18557  size_t item_size1key=shape[1];
18558  size_t valuelen1key;
18559  size_t item_size1val=(CYCLUS_SHA1_SIZE);
18560  size_t item_size2valelem=sizeof(double);
18561  size_t total_item_size1val=item_size2valelem;
18562  size_t total_item_size0=item_size1key+item_size1val;
18563  unsigned int count0=0;
18564  std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18565  std::map<std::string, std::vector<double>> fixed_val0;
18566  unsigned int pad_count0=0;
18567  for(;it0!=val0.end();++it0){
18568  std::string child1key=std::string(it0->first,0,item_size1key);
18569  fixed_val0[child1key] = it0->second;
18570  ++pad_count0;
18571 
18572  }
18573  hasher_.Clear();
18574  hasher_.Update(fixed_val0);
18575  Digest key0 = hasher_.digest();
18576  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_DOUBLE, true);
18577  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_DOUBLE, false);
18578  if (vlkeys_[VL_MAP_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
18579  hvl_t buf0 = VLValToBuf(fixed_val0);
18580  AppendVLKey(keysds0, VL_MAP_STRING_VL_VECTOR_DOUBLE, key0);
18581  InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_DOUBLE, key0, buf0);
18582  }
18583  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18584 }
18585 template<>
18586 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18587  std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18588  size_t item_size0=(CYCLUS_SHA1_SIZE);
18589  size_t item_size1key=CYCLUS_SHA1_SIZE;
18590  size_t item_size1val=((sizeof(double))*shape[2]);
18591  size_t length1val=shape[2];
18592  size_t item_size2valelem=sizeof(double);
18593  size_t total_item_size1val=item_size2valelem;
18594  size_t total_item_size0=item_size1key+item_size1val;
18595  unsigned int count0=0;
18596  std::map<std::string, std::vector<double>>::iterator it0=val0.begin();
18597  std::map<std::string, std::vector<double>> fixed_val0;
18598  unsigned int pad_count0=0;
18599  for(;it0!=val0.end();++it0){
18600  std::vector<double> child1val;
18601  unsigned int pad_count1val=0;
18602  std::vector<double>::iterator it1val=it0->second.begin();
18603  for(;it1val!=it0->second.end();++it1val){
18604  child1val.push_back((*it1val));
18605  ++pad_count1val;
18606 
18607  }
18608  child1val.resize(length1val);
18609  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
18610  fixed_val0[it0->first] = child1val;
18611  ++pad_count0;
18612 
18613  }
18614  hasher_.Clear();
18615  hasher_.Update(fixed_val0);
18616  Digest key0 = hasher_.digest();
18617  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_DOUBLE, true);
18618  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_DOUBLE, false);
18619  if (vlkeys_[VL_MAP_VL_STRING_VECTOR_DOUBLE].count(key0) != 1) {
18620  hvl_t buf0 = VLValToBuf(fixed_val0);
18621  AppendVLKey(keysds0, VL_MAP_VL_STRING_VECTOR_DOUBLE, key0);
18622  InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_DOUBLE, key0, buf0);
18623  }
18624  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18625 }
18626 template<>
18627 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18628  std::map<std::string, std::vector<double>> val0=a->cast<std::map<std::string, std::vector<double>>>();
18629  size_t item_size0=(CYCLUS_SHA1_SIZE);
18630  size_t item_size1key=CYCLUS_SHA1_SIZE;
18631  size_t item_size1val=(CYCLUS_SHA1_SIZE);
18632  size_t item_size2valelem=sizeof(double);
18633  size_t total_item_size1val=item_size2valelem;
18634  size_t total_item_size0=item_size1key+item_size1val;
18635  hasher_.Clear();
18636  hasher_.Update(val0);
18637  Digest key0 = hasher_.digest();
18638  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_DOUBLE, true);
18639  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_DOUBLE, false);
18640  if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
18641  hvl_t buf0 = VLValToBuf(val0);
18642  AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_VECTOR_DOUBLE, key0);
18643  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_DOUBLE, key0, buf0);
18644  }
18645  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18646 }
18647 template<>
18648 void Hdf5Back::WriteToBuf<MAP_STRING_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18649  std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18650  size_t item_size0=((shape[1]+((sizeof(int)+sizeof(double))*shape[2]))*shape[0]);
18651  size_t length0=shape[0];
18652  size_t item_size1key=shape[1];
18653  size_t valuelen1key;
18654  size_t item_size1val=((sizeof(int)+sizeof(double))*shape[2]);
18655  size_t length1val=shape[2];
18656  size_t item_size2valkey=sizeof(int);
18657  size_t item_size2valval=sizeof(double);
18658  size_t total_item_size1val=item_size2valkey+item_size2valval;
18659  size_t total_item_size0=item_size1key+item_size1val;
18660  if(total_item_size0*val0.size()>column){
18661  std::map<std::string, std::map<int, double>>::iterator eraseit=val0.begin();
18662  std::advance(eraseit, column/total_item_size0);
18663  val0.erase(eraseit,val0.end());
18664 
18665  }
18666  unsigned int count0=0;
18667  std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18668  for(;it0!=val0.end();++it0){
18669  valuelen1key=std::min(it0->first.size(), item_size1key);
18670  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18671  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18672  unsigned int count1val=0;
18673  std::map<int, double>::iterator it1val=it0->second.begin();
18674  for(;it1val!=it0->second.end();++it1val){
18675  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it1val->first), item_size2valkey);
18676  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
18677  ++count1val;
18678 
18679  }
18680  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
18681  ++count0;
18682 
18683  }
18684  if(total_item_size0*length0<column){
18685  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18686 
18687  }
18688 }
18689 template<>
18690 void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18691  std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18692  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
18693  size_t length0=shape[0];
18694  size_t item_size1key=shape[1];
18695  size_t valuelen1key;
18696  size_t item_size1val=(CYCLUS_SHA1_SIZE);
18697  size_t item_size2valkey=sizeof(int);
18698  size_t item_size2valval=sizeof(double);
18699  size_t total_item_size1val=item_size2valkey+item_size2valval;
18700  size_t total_item_size0=item_size1key+item_size1val;
18701  if(total_item_size0*val0.size()>column){
18702  std::map<std::string, std::map<int, double>>::iterator eraseit=val0.begin();
18703  std::advance(eraseit, column/total_item_size0);
18704  val0.erase(eraseit,val0.end());
18705 
18706  }
18707  unsigned int count0=0;
18708  std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18709  for(;it0!=val0.end();++it0){
18710  valuelen1key=std::min(it0->first.size(), item_size1key);
18711  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18712  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18713  hasher_.Clear();
18714  hasher_.Update(it0->second);
18715  Digest key1val = hasher_.digest();
18716  hid_t keysds1val = VLDataset(VL_MAP_INT_DOUBLE, true);
18717  hid_t valsds1val = VLDataset(VL_MAP_INT_DOUBLE, false);
18718  if (vlkeys_[VL_MAP_INT_DOUBLE].count(key1val) != 1) {
18719  hvl_t buf1val = VLValToBuf(it0->second);
18720  AppendVLKey(keysds1val, VL_MAP_INT_DOUBLE, key1val);
18721  InsertVLVal(valsds1val, VL_MAP_INT_DOUBLE, key1val, buf1val);
18722  }
18723  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
18724  ++count0;
18725 
18726  }
18727  if(total_item_size0*length0<column){
18728  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18729 
18730  }
18731 }
18732 template<>
18733 void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18734  std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18735  size_t item_size0=(CYCLUS_SHA1_SIZE);
18736  size_t item_size1key=shape[1];
18737  size_t valuelen1key;
18738  size_t item_size1val=((sizeof(int)+sizeof(double))*shape[2]);
18739  size_t length1val=shape[2];
18740  size_t item_size2valkey=sizeof(int);
18741  size_t item_size2valval=sizeof(double);
18742  size_t total_item_size1val=item_size2valkey+item_size2valval;
18743  size_t total_item_size0=item_size1key+item_size1val;
18744  unsigned int count0=0;
18745  std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18746  std::map<std::string, std::map<int, double>> fixed_val0;
18747  unsigned int pad_count0=0;
18748  for(;it0!=val0.end();++it0){
18749  std::string child1key=std::string(it0->first,0,item_size1key);
18750  std::map<int, double> child1val;
18751  unsigned int pad_count1val=0;
18752  std::map<int, double>::iterator it1val=it0->second.begin();
18753  for(;it1val!=it0->second.end();++it1val){
18754  child1val[it1val->first] = it1val->second;
18755  ++pad_count1val;
18756 
18757  }
18758  fixed_val0[child1key] = child1val;
18759  ++pad_count0;
18760 
18761  }
18762  hasher_.Clear();
18763  hasher_.Update(fixed_val0);
18764  Digest key0 = hasher_.digest();
18765  hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_INT_DOUBLE, true);
18766  hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_INT_DOUBLE, false);
18767  if (vlkeys_[VL_MAP_STRING_MAP_INT_DOUBLE].count(key0) != 1) {
18768  hvl_t buf0 = VLValToBuf(fixed_val0);
18769  AppendVLKey(keysds0, VL_MAP_STRING_MAP_INT_DOUBLE, key0);
18770  InsertVLVal(valsds0, VL_MAP_STRING_MAP_INT_DOUBLE, key0, buf0);
18771  }
18772  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18773 }
18774 template<>
18775 void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18776  std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18777  size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(int)+sizeof(double))*shape[2]))*shape[0]);
18778  size_t length0=shape[0];
18779  size_t item_size1key=CYCLUS_SHA1_SIZE;
18780  size_t item_size1val=((sizeof(int)+sizeof(double))*shape[2]);
18781  size_t length1val=shape[2];
18782  size_t item_size2valkey=sizeof(int);
18783  size_t item_size2valval=sizeof(double);
18784  size_t total_item_size1val=item_size2valkey+item_size2valval;
18785  size_t total_item_size0=item_size1key+item_size1val;
18786  if(total_item_size0*val0.size()>column){
18787  std::map<std::string, std::map<int, double>>::iterator eraseit=val0.begin();
18788  std::advance(eraseit, column/total_item_size0);
18789  val0.erase(eraseit,val0.end());
18790 
18791  }
18792  unsigned int count0=0;
18793  std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18794  for(;it0!=val0.end();++it0){
18795  hasher_.Clear();
18796  hasher_.Update(it0->first);
18797  Digest key1key = hasher_.digest();
18798  hid_t keysds1key = VLDataset(VL_STRING, true);
18799  hid_t valsds1key = VLDataset(VL_STRING, false);
18800  if (vlkeys_[VL_STRING].count(key1key) != 1) {
18801  AppendVLKey(keysds1key, VL_STRING, key1key);
18802  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18803  }
18804  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
18805  unsigned int count1val=0;
18806  std::map<int, double>::iterator it1val=it0->second.begin();
18807  for(;it1val!=it0->second.end();++it1val){
18808  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it1val->first), item_size2valkey);
18809  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
18810  ++count1val;
18811 
18812  }
18813  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
18814  ++count0;
18815 
18816  }
18817  if(total_item_size0*length0<column){
18818  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18819 
18820  }
18821 }
18822 template<>
18823 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18824  std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18825  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
18826  size_t length0=shape[0];
18827  size_t item_size1key=CYCLUS_SHA1_SIZE;
18828  size_t item_size1val=(CYCLUS_SHA1_SIZE);
18829  size_t item_size2valkey=sizeof(int);
18830  size_t item_size2valval=sizeof(double);
18831  size_t total_item_size1val=item_size2valkey+item_size2valval;
18832  size_t total_item_size0=item_size1key+item_size1val;
18833  if(total_item_size0*val0.size()>column){
18834  std::map<std::string, std::map<int, double>>::iterator eraseit=val0.begin();
18835  std::advance(eraseit, column/total_item_size0);
18836  val0.erase(eraseit,val0.end());
18837 
18838  }
18839  unsigned int count0=0;
18840  std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18841  for(;it0!=val0.end();++it0){
18842  hasher_.Clear();
18843  hasher_.Update(it0->first);
18844  Digest key1key = hasher_.digest();
18845  hid_t keysds1key = VLDataset(VL_STRING, true);
18846  hid_t valsds1key = VLDataset(VL_STRING, false);
18847  if (vlkeys_[VL_STRING].count(key1key) != 1) {
18848  AppendVLKey(keysds1key, VL_STRING, key1key);
18849  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
18850  }
18851  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
18852  hasher_.Clear();
18853  hasher_.Update(it0->second);
18854  Digest key1val = hasher_.digest();
18855  hid_t keysds1val = VLDataset(VL_MAP_INT_DOUBLE, true);
18856  hid_t valsds1val = VLDataset(VL_MAP_INT_DOUBLE, false);
18857  if (vlkeys_[VL_MAP_INT_DOUBLE].count(key1val) != 1) {
18858  hvl_t buf1val = VLValToBuf(it0->second);
18859  AppendVLKey(keysds1val, VL_MAP_INT_DOUBLE, key1val);
18860  InsertVLVal(valsds1val, VL_MAP_INT_DOUBLE, key1val, buf1val);
18861  }
18862  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
18863  ++count0;
18864 
18865  }
18866  if(total_item_size0*length0<column){
18867  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
18868 
18869  }
18870 }
18871 template<>
18872 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18873  std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18874  size_t item_size0=(CYCLUS_SHA1_SIZE);
18875  size_t item_size1key=shape[1];
18876  size_t valuelen1key;
18877  size_t item_size1val=(CYCLUS_SHA1_SIZE);
18878  size_t item_size2valkey=sizeof(int);
18879  size_t item_size2valval=sizeof(double);
18880  size_t total_item_size1val=item_size2valkey+item_size2valval;
18881  size_t total_item_size0=item_size1key+item_size1val;
18882  unsigned int count0=0;
18883  std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18884  std::map<std::string, std::map<int, double>> fixed_val0;
18885  unsigned int pad_count0=0;
18886  for(;it0!=val0.end();++it0){
18887  std::string child1key=std::string(it0->first,0,item_size1key);
18888  fixed_val0[child1key] = it0->second;
18889  ++pad_count0;
18890 
18891  }
18892  hasher_.Clear();
18893  hasher_.Update(fixed_val0);
18894  Digest key0 = hasher_.digest();
18895  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_INT_DOUBLE, true);
18896  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_INT_DOUBLE, false);
18897  if (vlkeys_[VL_MAP_STRING_VL_MAP_INT_DOUBLE].count(key0) != 1) {
18898  hvl_t buf0 = VLValToBuf(fixed_val0);
18899  AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_INT_DOUBLE, key0);
18900  InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_INT_DOUBLE, key0, buf0);
18901  }
18902  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18903 }
18904 template<>
18905 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18906  std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18907  size_t item_size0=(CYCLUS_SHA1_SIZE);
18908  size_t item_size1key=CYCLUS_SHA1_SIZE;
18909  size_t item_size1val=((sizeof(int)+sizeof(double))*shape[2]);
18910  size_t length1val=shape[2];
18911  size_t item_size2valkey=sizeof(int);
18912  size_t item_size2valval=sizeof(double);
18913  size_t total_item_size1val=item_size2valkey+item_size2valval;
18914  size_t total_item_size0=item_size1key+item_size1val;
18915  unsigned int count0=0;
18916  std::map<std::string, std::map<int, double>>::iterator it0=val0.begin();
18917  std::map<std::string, std::map<int, double>> fixed_val0;
18918  unsigned int pad_count0=0;
18919  for(;it0!=val0.end();++it0){
18920  std::map<int, double> child1val;
18921  unsigned int pad_count1val=0;
18922  std::map<int, double>::iterator it1val=it0->second.begin();
18923  for(;it1val!=it0->second.end();++it1val){
18924  child1val[it1val->first] = it1val->second;
18925  ++pad_count1val;
18926 
18927  }
18928  fixed_val0[it0->first] = child1val;
18929  ++pad_count0;
18930 
18931  }
18932  hasher_.Clear();
18933  hasher_.Update(fixed_val0);
18934  Digest key0 = hasher_.digest();
18935  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_INT_DOUBLE, true);
18936  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_INT_DOUBLE, false);
18937  if (vlkeys_[VL_MAP_VL_STRING_MAP_INT_DOUBLE].count(key0) != 1) {
18938  hvl_t buf0 = VLValToBuf(fixed_val0);
18939  AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_INT_DOUBLE, key0);
18940  InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_INT_DOUBLE, key0, buf0);
18941  }
18942  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18943 }
18944 template<>
18945 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18946  std::map<std::string, std::map<int, double>> val0=a->cast<std::map<std::string, std::map<int, double>>>();
18947  size_t item_size0=(CYCLUS_SHA1_SIZE);
18948  size_t item_size1key=CYCLUS_SHA1_SIZE;
18949  size_t item_size1val=(CYCLUS_SHA1_SIZE);
18950  size_t item_size2valkey=sizeof(int);
18951  size_t item_size2valval=sizeof(double);
18952  size_t total_item_size1val=item_size2valkey+item_size2valval;
18953  size_t total_item_size0=item_size1key+item_size1val;
18954  hasher_.Clear();
18955  hasher_.Update(val0);
18956  Digest key0 = hasher_.digest();
18957  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE, true);
18958  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE, false);
18959  if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE].count(key0) != 1) {
18960  hvl_t buf0 = VLValToBuf(val0);
18961  AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE, key0);
18962  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE, key0, buf0);
18963  }
18964  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
18965 }
18966 template<>
18967 void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
18968  std::map<std::string, std::pair<double, std::map<int, double>>> val0=a->cast<std::map<std::string, std::pair<double, std::map<int, double>>>>();
18969  size_t item_size0=((shape[1]+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))))*shape[0]);
18970  size_t length0=shape[0];
18971  size_t item_size1key=shape[1];
18972  size_t valuelen1key;
18973  size_t item_size1val=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4])));
18974  size_t item_size2valfirst=sizeof(double);
18975  size_t item_size2valsecond=((sizeof(int)+sizeof(double))*shape[4]);
18976  size_t length2valsecond=shape[4];
18977  size_t item_size3valsecondkey=sizeof(int);
18978  size_t item_size3valsecondval=sizeof(double);
18979  size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
18980  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
18981  size_t total_item_size0=item_size1key+item_size1val;
18982  if(total_item_size0*val0.size()>column){
18983  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator eraseit=val0.begin();
18984  std::advance(eraseit, column/total_item_size0);
18985  val0.erase(eraseit,val0.end());
18986 
18987  }
18988  unsigned int count0=0;
18989  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
18990  for(;it0!=val0.end();++it0){
18991  valuelen1key=std::min(it0->first.size(), item_size1key);
18992  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
18993  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
18994  unsigned int count1val=0;
18995  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it0->second.first), item_size2valfirst);
18996  unsigned int count2valsecond=0;
18997  std::map<int, double>::iterator it2valsecond=it0->second.second.begin();
18998  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
18999  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+(count2valsecond*total_item_size2valsecond)+0, &(it2valsecond->first), item_size3valsecondkey);
19000  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+(count2valsecond*total_item_size2valsecond)+0+item_size3valsecondkey, &(it2valsecond->second), item_size3valsecondval);
19001  ++count2valsecond;
19002 
19003  }
19004  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+total_item_size2valsecond*count2valsecond, 0, total_item_size2valsecond*(length2valsecond-count2valsecond));
19005  ++count0;
19006 
19007  }
19008  if(total_item_size0*length0<column){
19009  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19010 
19011  }
19012 }
19013 template<>
19014 void Hdf5Back::WriteToBuf<VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19015  std::map<std::string, std::pair<double, std::map<int, double>>> val0=a->cast<std::map<std::string, std::pair<double, std::map<int, double>>>>();
19016  size_t item_size0=(CYCLUS_SHA1_SIZE);
19017  size_t item_size1key=shape[1];
19018  size_t valuelen1key;
19019  size_t item_size1val=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4])));
19020  size_t item_size2valfirst=sizeof(double);
19021  size_t item_size2valsecond=((sizeof(int)+sizeof(double))*shape[4]);
19022  size_t length2valsecond=shape[4];
19023  size_t item_size3valsecondkey=sizeof(int);
19024  size_t item_size3valsecondval=sizeof(double);
19025  size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19026  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19027  size_t total_item_size0=item_size1key+item_size1val;
19028  unsigned int count0=0;
19029  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19030  std::map<std::string, std::pair<double, std::map<int, double>>> fixed_val0;
19031  unsigned int pad_count0=0;
19032  for(;it0!=val0.end();++it0){
19033  std::string child1key=std::string(it0->first,0,item_size1key);
19034  std::pair<double, std::map<int, double>> child1val;
19035  unsigned int pad_count1val=0;
19036  std::map<int, double> child2valsecond;
19037  unsigned int pad_count2valsecond=0;
19038  std::map<int, double>::iterator it2valsecond=it0->second.second.begin();
19039  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
19040  child2valsecond[it2valsecond->first] = it2valsecond->second;
19041  ++pad_count2valsecond;
19042 
19043  }
19044  child1val = std::make_pair(it0->second.first,child2valsecond);
19045  fixed_val0[child1key] = child1val;
19046  ++pad_count0;
19047 
19048  }
19049  hasher_.Clear();
19050  hasher_.Update(fixed_val0);
19051  Digest key0 = hasher_.digest();
19052  hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, true);
19053  hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, false);
19054  if (vlkeys_[VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE].count(key0) != 1) {
19055  hvl_t buf0 = VLValToBuf(fixed_val0);
19056  AppendVLKey(keysds0, VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, key0);
19057  InsertVLVal(valsds0, VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, key0, buf0);
19058  }
19059  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
19060 }
19061 template<>
19062 void Hdf5Back::WriteToBuf<MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19063  std::map<std::string, std::pair<double, std::map<int, double>>> val0=a->cast<std::map<std::string, std::pair<double, std::map<int, double>>>>();
19064  size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4]))))*shape[0]);
19065  size_t length0=shape[0];
19066  size_t item_size1key=CYCLUS_SHA1_SIZE;
19067  size_t item_size1val=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4])));
19068  size_t item_size2valfirst=sizeof(double);
19069  size_t item_size2valsecond=((sizeof(int)+sizeof(double))*shape[4]);
19070  size_t length2valsecond=shape[4];
19071  size_t item_size3valsecondkey=sizeof(int);
19072  size_t item_size3valsecondval=sizeof(double);
19073  size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19074  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19075  size_t total_item_size0=item_size1key+item_size1val;
19076  if(total_item_size0*val0.size()>column){
19077  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator eraseit=val0.begin();
19078  std::advance(eraseit, column/total_item_size0);
19079  val0.erase(eraseit,val0.end());
19080 
19081  }
19082  unsigned int count0=0;
19083  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19084  for(;it0!=val0.end();++it0){
19085  hasher_.Clear();
19086  hasher_.Update(it0->first);
19087  Digest key1key = hasher_.digest();
19088  hid_t keysds1key = VLDataset(VL_STRING, true);
19089  hid_t valsds1key = VLDataset(VL_STRING, false);
19090  if (vlkeys_[VL_STRING].count(key1key) != 1) {
19091  AppendVLKey(keysds1key, VL_STRING, key1key);
19092  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
19093  }
19094  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
19095  unsigned int count1val=0;
19096  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it0->second.first), item_size2valfirst);
19097  unsigned int count2valsecond=0;
19098  std::map<int, double>::iterator it2valsecond=it0->second.second.begin();
19099  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
19100  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+(count2valsecond*total_item_size2valsecond)+0, &(it2valsecond->first), item_size3valsecondkey);
19101  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+(count2valsecond*total_item_size2valsecond)+0+item_size3valsecondkey, &(it2valsecond->second), item_size3valsecondval);
19102  ++count2valsecond;
19103 
19104  }
19105  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+total_item_size2valsecond*count2valsecond, 0, total_item_size2valsecond*(length2valsecond-count2valsecond));
19106  ++count0;
19107 
19108  }
19109  if(total_item_size0*length0<column){
19110  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19111 
19112  }
19113 }
19114 template<>
19115 void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19116  std::map<std::string, std::pair<double, std::map<int, double>>> val0=a->cast<std::map<std::string, std::pair<double, std::map<int, double>>>>();
19117  size_t item_size0=((shape[1]+((sizeof(double)+(CYCLUS_SHA1_SIZE))))*shape[0]);
19118  size_t length0=shape[0];
19119  size_t item_size1key=shape[1];
19120  size_t valuelen1key;
19121  size_t item_size1val=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
19122  size_t item_size2valfirst=sizeof(double);
19123  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
19124  size_t item_size3valsecondkey=sizeof(int);
19125  size_t item_size3valsecondval=sizeof(double);
19126  size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19127  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19128  size_t total_item_size0=item_size1key+item_size1val;
19129  if(total_item_size0*val0.size()>column){
19130  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator eraseit=val0.begin();
19131  std::advance(eraseit, column/total_item_size0);
19132  val0.erase(eraseit,val0.end());
19133 
19134  }
19135  unsigned int count0=0;
19136  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19137  for(;it0!=val0.end();++it0){
19138  valuelen1key=std::min(it0->first.size(), item_size1key);
19139  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19140  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19141  unsigned int count1val=0;
19142  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it0->second.first), item_size2valfirst);
19143  hasher_.Clear();
19144  hasher_.Update(it0->second.second);
19145  Digest key2valsecond = hasher_.digest();
19146  hid_t keysds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, true);
19147  hid_t valsds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, false);
19148  if (vlkeys_[VL_MAP_INT_DOUBLE].count(key2valsecond) != 1) {
19149  hvl_t buf2valsecond = VLValToBuf(it0->second.second);
19150  AppendVLKey(keysds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond);
19151  InsertVLVal(valsds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond, buf2valsecond);
19152  }
19153  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.val, CYCLUS_SHA1_SIZE);
19154  ++count0;
19155 
19156  }
19157  if(total_item_size0*length0<column){
19158  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19159 
19160  }
19161 }
19162 template<>
19163 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19164  std::map<std::string, std::pair<double, std::map<int, double>>> val0=a->cast<std::map<std::string, std::pair<double, std::map<int, double>>>>();
19165  size_t item_size0=(CYCLUS_SHA1_SIZE);
19166  size_t item_size1key=CYCLUS_SHA1_SIZE;
19167  size_t item_size1val=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[4])));
19168  size_t item_size2valfirst=sizeof(double);
19169  size_t item_size2valsecond=((sizeof(int)+sizeof(double))*shape[4]);
19170  size_t length2valsecond=shape[4];
19171  size_t item_size3valsecondkey=sizeof(int);
19172  size_t item_size3valsecondval=sizeof(double);
19173  size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19174  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19175  size_t total_item_size0=item_size1key+item_size1val;
19176  unsigned int count0=0;
19177  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19178  std::map<std::string, std::pair<double, std::map<int, double>>> fixed_val0;
19179  unsigned int pad_count0=0;
19180  for(;it0!=val0.end();++it0){
19181  std::pair<double, std::map<int, double>> child1val;
19182  unsigned int pad_count1val=0;
19183  std::map<int, double> child2valsecond;
19184  unsigned int pad_count2valsecond=0;
19185  std::map<int, double>::iterator it2valsecond=it0->second.second.begin();
19186  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
19187  child2valsecond[it2valsecond->first] = it2valsecond->second;
19188  ++pad_count2valsecond;
19189 
19190  }
19191  child1val = std::make_pair(it0->second.first,child2valsecond);
19192  fixed_val0[it0->first] = child1val;
19193  ++pad_count0;
19194 
19195  }
19196  hasher_.Clear();
19197  hasher_.Update(fixed_val0);
19198  Digest key0 = hasher_.digest();
19199  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, true);
19200  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, false);
19201  if (vlkeys_[VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE].count(key0) != 1) {
19202  hvl_t buf0 = VLValToBuf(fixed_val0);
19203  AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, key0);
19204  InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE, key0, buf0);
19205  }
19206  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
19207 }
19208 template<>
19209 void Hdf5Back::WriteToBuf<VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19210  std::map<std::string, std::pair<double, std::map<int, double>>> val0=a->cast<std::map<std::string, std::pair<double, std::map<int, double>>>>();
19211  size_t item_size0=(CYCLUS_SHA1_SIZE);
19212  size_t item_size1key=shape[1];
19213  size_t valuelen1key;
19214  size_t item_size1val=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
19215  size_t item_size2valfirst=sizeof(double);
19216  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
19217  size_t item_size3valsecondkey=sizeof(int);
19218  size_t item_size3valsecondval=sizeof(double);
19219  size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19220  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19221  size_t total_item_size0=item_size1key+item_size1val;
19222  unsigned int count0=0;
19223  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19224  std::map<std::string, std::pair<double, std::map<int, double>>> fixed_val0;
19225  unsigned int pad_count0=0;
19226  for(;it0!=val0.end();++it0){
19227  std::string child1key=std::string(it0->first,0,item_size1key);
19228  std::pair<double, std::map<int, double>> child1val;
19229  unsigned int pad_count1val=0;
19230  child1val = std::make_pair(it0->second.first,it0->second.second);
19231  fixed_val0[child1key] = child1val;
19232  ++pad_count0;
19233 
19234  }
19235  hasher_.Clear();
19236  hasher_.Update(fixed_val0);
19237  Digest key0 = hasher_.digest();
19238  hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, true);
19239  hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, false);
19240  if (vlkeys_[VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE].count(key0) != 1) {
19241  hvl_t buf0 = VLValToBuf(fixed_val0);
19242  AppendVLKey(keysds0, VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, key0);
19243  InsertVLVal(valsds0, VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, key0, buf0);
19244  }
19245  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
19246 }
19247 template<>
19248 void Hdf5Back::WriteToBuf<MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19249  std::map<std::string, std::pair<double, std::map<int, double>>> val0=a->cast<std::map<std::string, std::pair<double, std::map<int, double>>>>();
19250  size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(double)+(CYCLUS_SHA1_SIZE))))*shape[0]);
19251  size_t length0=shape[0];
19252  size_t item_size1key=CYCLUS_SHA1_SIZE;
19253  size_t item_size1val=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
19254  size_t item_size2valfirst=sizeof(double);
19255  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
19256  size_t item_size3valsecondkey=sizeof(int);
19257  size_t item_size3valsecondval=sizeof(double);
19258  size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19259  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19260  size_t total_item_size0=item_size1key+item_size1val;
19261  if(total_item_size0*val0.size()>column){
19262  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator eraseit=val0.begin();
19263  std::advance(eraseit, column/total_item_size0);
19264  val0.erase(eraseit,val0.end());
19265 
19266  }
19267  unsigned int count0=0;
19268  std::map<std::string, std::pair<double, std::map<int, double>>>::iterator it0=val0.begin();
19269  for(;it0!=val0.end();++it0){
19270  hasher_.Clear();
19271  hasher_.Update(it0->first);
19272  Digest key1key = hasher_.digest();
19273  hid_t keysds1key = VLDataset(VL_STRING, true);
19274  hid_t valsds1key = VLDataset(VL_STRING, false);
19275  if (vlkeys_[VL_STRING].count(key1key) != 1) {
19276  AppendVLKey(keysds1key, VL_STRING, key1key);
19277  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
19278  }
19279  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
19280  unsigned int count1val=0;
19281  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, &(it0->second.first), item_size2valfirst);
19282  hasher_.Clear();
19283  hasher_.Update(it0->second.second);
19284  Digest key2valsecond = hasher_.digest();
19285  hid_t keysds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, true);
19286  hid_t valsds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, false);
19287  if (vlkeys_[VL_MAP_INT_DOUBLE].count(key2valsecond) != 1) {
19288  hvl_t buf2valsecond = VLValToBuf(it0->second.second);
19289  AppendVLKey(keysds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond);
19290  InsertVLVal(valsds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond, buf2valsecond);
19291  }
19292  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.val, CYCLUS_SHA1_SIZE);
19293  ++count0;
19294 
19295  }
19296  if(total_item_size0*length0<column){
19297  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19298 
19299  }
19300 }
19301 template<>
19302 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19303  std::map<std::string, std::pair<double, std::map<int, double>>> val0=a->cast<std::map<std::string, std::pair<double, std::map<int, double>>>>();
19304  size_t item_size0=(CYCLUS_SHA1_SIZE);
19305  size_t item_size1key=CYCLUS_SHA1_SIZE;
19306  size_t item_size1val=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
19307  size_t item_size2valfirst=sizeof(double);
19308  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
19309  size_t item_size3valsecondkey=sizeof(int);
19310  size_t item_size3valsecondval=sizeof(double);
19311  size_t total_item_size2valsecond=item_size3valsecondkey+item_size3valsecondval;
19312  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
19313  size_t total_item_size0=item_size1key+item_size1val;
19314  hasher_.Clear();
19315  hasher_.Update(val0);
19316  Digest key0 = hasher_.digest();
19317  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, true);
19318  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, false);
19319  if (vlkeys_[VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE].count(key0) != 1) {
19320  hvl_t buf0 = VLValToBuf(val0);
19321  AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, key0);
19322  InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE, key0, buf0);
19323  }
19324  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
19325 }
19326 template<>
19327 void Hdf5Back::WriteToBuf<MAP_INT_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19328  std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19329  size_t item_size0=((sizeof(int)+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
19330  size_t length0=shape[0];
19331  size_t item_size1key=sizeof(int);
19332  size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
19333  size_t length1val=shape[2];
19334  size_t item_size2valkey=shape[3];
19335  size_t valuelen2valkey;
19336  size_t item_size2valval=sizeof(double);
19337  size_t total_item_size1val=item_size2valkey+item_size2valval;
19338  size_t total_item_size0=item_size1key+item_size1val;
19339  if(total_item_size0*val0.size()>column){
19340  std::map<int, std::map<std::string, double>>::iterator eraseit=val0.begin();
19341  std::advance(eraseit, column/total_item_size0);
19342  val0.erase(eraseit,val0.end());
19343 
19344  }
19345  unsigned int count0=0;
19346  std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19347  for(;it0!=val0.end();++it0){
19348  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
19349  unsigned int count1val=0;
19350  std::map<std::string, double>::iterator it1val=it0->second.begin();
19351  for(;it1val!=it0->second.end();++it1val){
19352  valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
19353  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
19354  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
19355  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
19356  ++count1val;
19357 
19358  }
19359  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19360  ++count0;
19361 
19362  }
19363  if(total_item_size0*length0<column){
19364  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19365 
19366  }
19367 }
19368 template<>
19369 void Hdf5Back::WriteToBuf<MAP_INT_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19370  std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19371  size_t item_size0=((sizeof(int)+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
19372  size_t length0=shape[0];
19373  size_t item_size1key=sizeof(int);
19374  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
19375  size_t length1val=shape[2];
19376  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
19377  size_t item_size2valval=sizeof(double);
19378  size_t total_item_size1val=item_size2valkey+item_size2valval;
19379  size_t total_item_size0=item_size1key+item_size1val;
19380  if(total_item_size0*val0.size()>column){
19381  std::map<int, std::map<std::string, double>>::iterator eraseit=val0.begin();
19382  std::advance(eraseit, column/total_item_size0);
19383  val0.erase(eraseit,val0.end());
19384 
19385  }
19386  unsigned int count0=0;
19387  std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19388  for(;it0!=val0.end();++it0){
19389  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
19390  unsigned int count1val=0;
19391  std::map<std::string, double>::iterator it1val=it0->second.begin();
19392  for(;it1val!=it0->second.end();++it1val){
19393  hasher_.Clear();
19394  hasher_.Update(it1val->first);
19395  Digest key2valkey = hasher_.digest();
19396  hid_t keysds2valkey = VLDataset(VL_STRING, true);
19397  hid_t valsds2valkey = VLDataset(VL_STRING, false);
19398  if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
19399  AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
19400  InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
19401  }
19402  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.val, CYCLUS_SHA1_SIZE);
19403  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
19404  ++count1val;
19405 
19406  }
19407  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19408  ++count0;
19409 
19410  }
19411  if(total_item_size0*length0<column){
19412  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19413 
19414  }
19415 }
19416 template<>
19417 void Hdf5Back::WriteToBuf<VL_MAP_INT_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19418  std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19419  size_t item_size0=(CYCLUS_SHA1_SIZE);
19420  size_t item_size1key=sizeof(int);
19421  size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
19422  size_t length1val=shape[2];
19423  size_t item_size2valkey=shape[3];
19424  size_t valuelen2valkey;
19425  size_t item_size2valval=sizeof(double);
19426  size_t total_item_size1val=item_size2valkey+item_size2valval;
19427  size_t total_item_size0=item_size1key+item_size1val;
19428  unsigned int count0=0;
19429  std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19430  std::map<int, std::map<std::string, double>> fixed_val0;
19431  unsigned int pad_count0=0;
19432  for(;it0!=val0.end();++it0){
19433  std::map<std::string, double> child1val;
19434  unsigned int pad_count1val=0;
19435  std::map<std::string, double>::iterator it1val=it0->second.begin();
19436  for(;it1val!=it0->second.end();++it1val){
19437  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
19438  child1val[child2valkey] = it1val->second;
19439  ++pad_count1val;
19440 
19441  }
19442  fixed_val0[it0->first] = child1val;
19443  ++pad_count0;
19444 
19445  }
19446  hasher_.Clear();
19447  hasher_.Update(fixed_val0);
19448  Digest key0 = hasher_.digest();
19449  hid_t keysds0 = VLDataset(VL_MAP_INT_MAP_STRING_DOUBLE, true);
19450  hid_t valsds0 = VLDataset(VL_MAP_INT_MAP_STRING_DOUBLE, false);
19451  if (vlkeys_[VL_MAP_INT_MAP_STRING_DOUBLE].count(key0) != 1) {
19452  hvl_t buf0 = VLValToBuf(fixed_val0);
19453  AppendVLKey(keysds0, VL_MAP_INT_MAP_STRING_DOUBLE, key0);
19454  InsertVLVal(valsds0, VL_MAP_INT_MAP_STRING_DOUBLE, key0, buf0);
19455  }
19456  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
19457 }
19458 template<>
19459 void Hdf5Back::WriteToBuf<VL_MAP_INT_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19460  std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19461  size_t item_size0=(CYCLUS_SHA1_SIZE);
19462  size_t item_size1key=sizeof(int);
19463  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
19464  size_t length1val=shape[2];
19465  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
19466  size_t item_size2valval=sizeof(double);
19467  size_t total_item_size1val=item_size2valkey+item_size2valval;
19468  size_t total_item_size0=item_size1key+item_size1val;
19469  unsigned int count0=0;
19470  std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19471  std::map<int, std::map<std::string, double>> fixed_val0;
19472  unsigned int pad_count0=0;
19473  for(;it0!=val0.end();++it0){
19474  std::map<std::string, double> child1val;
19475  unsigned int pad_count1val=0;
19476  std::map<std::string, double>::iterator it1val=it0->second.begin();
19477  for(;it1val!=it0->second.end();++it1val){
19478  child1val[it1val->first] = it1val->second;
19479  ++pad_count1val;
19480 
19481  }
19482  fixed_val0[it0->first] = child1val;
19483  ++pad_count0;
19484 
19485  }
19486  hasher_.Clear();
19487  hasher_.Update(fixed_val0);
19488  Digest key0 = hasher_.digest();
19489  hid_t keysds0 = VLDataset(VL_MAP_INT_MAP_VL_STRING_DOUBLE, true);
19490  hid_t valsds0 = VLDataset(VL_MAP_INT_MAP_VL_STRING_DOUBLE, false);
19491  if (vlkeys_[VL_MAP_INT_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
19492  hvl_t buf0 = VLValToBuf(fixed_val0);
19493  AppendVLKey(keysds0, VL_MAP_INT_MAP_VL_STRING_DOUBLE, key0);
19494  InsertVLVal(valsds0, VL_MAP_INT_MAP_VL_STRING_DOUBLE, key0, buf0);
19495  }
19496  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
19497 }
19498 template<>
19499 void Hdf5Back::WriteToBuf<MAP_INT_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19500  std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19501  size_t item_size0=((sizeof(int)+(CYCLUS_SHA1_SIZE))*shape[0]);
19502  size_t length0=shape[0];
19503  size_t item_size1key=sizeof(int);
19504  size_t item_size1val=(CYCLUS_SHA1_SIZE);
19505  size_t item_size2valkey=shape[3];
19506  size_t valuelen2valkey;
19507  size_t item_size2valval=sizeof(double);
19508  size_t total_item_size1val=item_size2valkey+item_size2valval;
19509  size_t total_item_size0=item_size1key+item_size1val;
19510  if(total_item_size0*val0.size()>column){
19511  std::map<int, std::map<std::string, double>>::iterator eraseit=val0.begin();
19512  std::advance(eraseit, column/total_item_size0);
19513  val0.erase(eraseit,val0.end());
19514 
19515  }
19516  unsigned int count0=0;
19517  std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19518  for(;it0!=val0.end();++it0){
19519  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
19520  unsigned int count1val=0;
19521  std::map<std::string, double>::iterator it1val=it0->second.begin();
19522  std::map<std::string, double> fixed_val1val;
19523  unsigned int pad_count1val=0;
19524  for(;it1val!=it0->second.end();++it1val){
19525  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
19526  fixed_val1val[child2valkey] = it1val->second;
19527  ++pad_count1val;
19528 
19529  }
19530  hasher_.Clear();
19531  hasher_.Update(fixed_val1val);
19532  Digest key1val = hasher_.digest();
19533  hid_t keysds1val = VLDataset(VL_MAP_STRING_DOUBLE, true);
19534  hid_t valsds1val = VLDataset(VL_MAP_STRING_DOUBLE, false);
19535  if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key1val) != 1) {
19536  hvl_t buf1val = VLValToBuf(fixed_val1val);
19537  AppendVLKey(keysds1val, VL_MAP_STRING_DOUBLE, key1val);
19538  InsertVLVal(valsds1val, VL_MAP_STRING_DOUBLE, key1val, buf1val);
19539  }
19540  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
19541  ++count0;
19542 
19543  }
19544  if(total_item_size0*length0<column){
19545  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19546 
19547  }
19548 }
19549 template<>
19550 void Hdf5Back::WriteToBuf<MAP_INT_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19551  std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19552  size_t item_size0=((sizeof(int)+(CYCLUS_SHA1_SIZE))*shape[0]);
19553  size_t length0=shape[0];
19554  size_t item_size1key=sizeof(int);
19555  size_t item_size1val=(CYCLUS_SHA1_SIZE);
19556  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
19557  size_t item_size2valval=sizeof(double);
19558  size_t total_item_size1val=item_size2valkey+item_size2valval;
19559  size_t total_item_size0=item_size1key+item_size1val;
19560  if(total_item_size0*val0.size()>column){
19561  std::map<int, std::map<std::string, double>>::iterator eraseit=val0.begin();
19562  std::advance(eraseit, column/total_item_size0);
19563  val0.erase(eraseit,val0.end());
19564 
19565  }
19566  unsigned int count0=0;
19567  std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19568  for(;it0!=val0.end();++it0){
19569  memcpy(buf+(count0*total_item_size0)+0, &(it0->first), item_size1key);
19570  hasher_.Clear();
19571  hasher_.Update(it0->second);
19572  Digest key1val = hasher_.digest();
19573  hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
19574  hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
19575  if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
19576  hvl_t buf1val = VLValToBuf(it0->second);
19577  AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
19578  InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
19579  }
19580  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
19581  ++count0;
19582 
19583  }
19584  if(total_item_size0*length0<column){
19585  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19586 
19587  }
19588 }
19589 template<>
19590 void Hdf5Back::WriteToBuf<VL_MAP_INT_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19591  std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19592  size_t item_size0=(CYCLUS_SHA1_SIZE);
19593  size_t item_size1key=sizeof(int);
19594  size_t item_size1val=(CYCLUS_SHA1_SIZE);
19595  size_t item_size2valkey=shape[3];
19596  size_t valuelen2valkey;
19597  size_t item_size2valval=sizeof(double);
19598  size_t total_item_size1val=item_size2valkey+item_size2valval;
19599  size_t total_item_size0=item_size1key+item_size1val;
19600  unsigned int count0=0;
19601  std::map<int, std::map<std::string, double>>::iterator it0=val0.begin();
19602  std::map<int, std::map<std::string, double>> fixed_val0;
19603  unsigned int pad_count0=0;
19604  for(;it0!=val0.end();++it0){
19605  std::map<std::string, double> child1val;
19606  unsigned int pad_count1val=0;
19607  std::map<std::string, double>::iterator it1val=it0->second.begin();
19608  for(;it1val!=it0->second.end();++it1val){
19609  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
19610  child1val[child2valkey] = it1val->second;
19611  ++pad_count1val;
19612 
19613  }
19614  fixed_val0[it0->first] = child1val;
19615  ++pad_count0;
19616 
19617  }
19618  hasher_.Clear();
19619  hasher_.Update(fixed_val0);
19620  Digest key0 = hasher_.digest();
19621  hid_t keysds0 = VLDataset(VL_MAP_INT_VL_MAP_STRING_DOUBLE, true);
19622  hid_t valsds0 = VLDataset(VL_MAP_INT_VL_MAP_STRING_DOUBLE, false);
19623  if (vlkeys_[VL_MAP_INT_VL_MAP_STRING_DOUBLE].count(key0) != 1) {
19624  hvl_t buf0 = VLValToBuf(fixed_val0);
19625  AppendVLKey(keysds0, VL_MAP_INT_VL_MAP_STRING_DOUBLE, key0);
19626  InsertVLVal(valsds0, VL_MAP_INT_VL_MAP_STRING_DOUBLE, key0, buf0);
19627  }
19628  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
19629 }
19630 template<>
19631 void Hdf5Back::WriteToBuf<VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19632  std::map<int, std::map<std::string, double>> val0=a->cast<std::map<int, std::map<std::string, double>>>();
19633  size_t item_size0=(CYCLUS_SHA1_SIZE);
19634  size_t item_size1key=sizeof(int);
19635  size_t item_size1val=(CYCLUS_SHA1_SIZE);
19636  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
19637  size_t item_size2valval=sizeof(double);
19638  size_t total_item_size1val=item_size2valkey+item_size2valval;
19639  size_t total_item_size0=item_size1key+item_size1val;
19640  hasher_.Clear();
19641  hasher_.Update(val0);
19642  Digest key0 = hasher_.digest();
19643  hid_t keysds0 = VLDataset(VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE, true);
19644  hid_t valsds0 = VLDataset(VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE, false);
19645  if (vlkeys_[VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
19646  hvl_t buf0 = VLValToBuf(val0);
19647  AppendVLKey(keysds0, VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE, key0);
19648  InsertVLVal(valsds0, VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE, key0, buf0);
19649  }
19650  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
19651 }
19652 template<>
19653 void Hdf5Back::WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19654  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
19655  size_t item_size0=((shape[1]+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]))*shape[0]);
19656  size_t length0=shape[0];
19657  size_t item_size1key=shape[1];
19658  size_t valuelen1key;
19659  size_t item_size1val=((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]);
19660  size_t length1val=shape[2];
19661  size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
19662  size_t item_size3valelemfirst=sizeof(int);
19663  size_t item_size3valelemsecond=((shape[6]+shape[7]));
19664  size_t item_size4valelemsecondfirst=shape[6];
19665  size_t valuelen4valelemsecondfirst;
19666  size_t item_size4valelemsecondsecond=shape[7];
19667  size_t valuelen4valelemsecondsecond;
19668  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19669  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19670  size_t total_item_size1val=item_size2valelem;
19671  size_t total_item_size0=item_size1key+item_size1val;
19672  if(total_item_size0*val0.size()>column){
19673  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19674  std::advance(eraseit, column/total_item_size0);
19675  val0.erase(eraseit,val0.end());
19676 
19677  }
19678  unsigned int count0=0;
19679  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19680  for(;it0!=val0.end();++it0){
19681  valuelen1key=std::min(it0->first.size(), item_size1key);
19682  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19683  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19684  unsigned int count1val=0;
19685  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19686  for(;it1val!=it0->second.end();++it1val){
19687  unsigned int count2valelem=0;
19688  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
19689  unsigned int count3valelemsecond=0;
19690  valuelen4valelemsecondfirst=std::min(it1val->second.first.size(), item_size4valelemsecondfirst);
19691  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0, it1val->second.first.c_str(), valuelen4valelemsecondfirst);
19692  memset(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+valuelen4valelemsecondfirst, 0, item_size4valelemsecondfirst-valuelen4valelemsecondfirst);
19693  valuelen4valelemsecondsecond=std::min(it1val->second.second.size(), item_size4valelemsecondsecond);
19694  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst, it1val->second.second.c_str(), valuelen4valelemsecondsecond);
19695  memset(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst+valuelen4valelemsecondsecond, 0, item_size4valelemsecondsecond-valuelen4valelemsecondsecond);
19696  ++count1val;
19697 
19698  }
19699  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19700  ++count0;
19701 
19702  }
19703  if(total_item_size0*length0<column){
19704  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19705 
19706  }
19707 }
19708 template<>
19709 void Hdf5Back::WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19710  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
19711  size_t item_size0=((shape[1]+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
19712  size_t length0=shape[0];
19713  size_t item_size1key=shape[1];
19714  size_t valuelen1key;
19715  size_t item_size1val=((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]);
19716  size_t length1val=shape[2];
19717  size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
19718  size_t item_size3valelemfirst=sizeof(int);
19719  size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
19720  size_t item_size4valelemsecondfirst=shape[6];
19721  size_t valuelen4valelemsecondfirst;
19722  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
19723  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19724  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19725  size_t total_item_size1val=item_size2valelem;
19726  size_t total_item_size0=item_size1key+item_size1val;
19727  if(total_item_size0*val0.size()>column){
19728  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19729  std::advance(eraseit, column/total_item_size0);
19730  val0.erase(eraseit,val0.end());
19731 
19732  }
19733  unsigned int count0=0;
19734  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19735  for(;it0!=val0.end();++it0){
19736  valuelen1key=std::min(it0->first.size(), item_size1key);
19737  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19738  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19739  unsigned int count1val=0;
19740  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19741  for(;it1val!=it0->second.end();++it1val){
19742  unsigned int count2valelem=0;
19743  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
19744  unsigned int count3valelemsecond=0;
19745  valuelen4valelemsecondfirst=std::min(it1val->second.first.size(), item_size4valelemsecondfirst);
19746  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0, it1val->second.first.c_str(), valuelen4valelemsecondfirst);
19747  memset(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+valuelen4valelemsecondfirst, 0, item_size4valelemsecondfirst-valuelen4valelemsecondfirst);
19748  hasher_.Clear();
19749  hasher_.Update(it1val->second.second);
19750  Digest key4valelemsecondsecond = hasher_.digest();
19751  hid_t keysds4valelemsecondsecond = VLDataset(VL_STRING, true);
19752  hid_t valsds4valelemsecondsecond = VLDataset(VL_STRING, false);
19753  if (vlkeys_[VL_STRING].count(key4valelemsecondsecond) != 1) {
19754  AppendVLKey(keysds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond);
19755  InsertVLVal(valsds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond, it1val->second.second);
19756  }
19757  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst, key4valelemsecondsecond.val, CYCLUS_SHA1_SIZE);
19758  ++count1val;
19759 
19760  }
19761  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19762  ++count0;
19763 
19764  }
19765  if(total_item_size0*length0<column){
19766  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19767 
19768  }
19769 }
19770 template<>
19771 void Hdf5Back::WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19772  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
19773  size_t item_size0=((shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]))*shape[0]);
19774  size_t length0=shape[0];
19775  size_t item_size1key=shape[1];
19776  size_t valuelen1key;
19777  size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]);
19778  size_t length1val=shape[2];
19779  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
19780  size_t item_size3valelemfirst=sizeof(int);
19781  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
19782  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
19783  size_t item_size4valelemsecondsecond=shape[7];
19784  size_t valuelen4valelemsecondsecond;
19785  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19786  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19787  size_t total_item_size1val=item_size2valelem;
19788  size_t total_item_size0=item_size1key+item_size1val;
19789  if(total_item_size0*val0.size()>column){
19790  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19791  std::advance(eraseit, column/total_item_size0);
19792  val0.erase(eraseit,val0.end());
19793 
19794  }
19795  unsigned int count0=0;
19796  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19797  for(;it0!=val0.end();++it0){
19798  valuelen1key=std::min(it0->first.size(), item_size1key);
19799  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19800  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19801  unsigned int count1val=0;
19802  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19803  for(;it1val!=it0->second.end();++it1val){
19804  unsigned int count2valelem=0;
19805  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
19806  unsigned int count3valelemsecond=0;
19807  hasher_.Clear();
19808  hasher_.Update(it1val->second.first);
19809  Digest key4valelemsecondfirst = hasher_.digest();
19810  hid_t keysds4valelemsecondfirst = VLDataset(VL_STRING, true);
19811  hid_t valsds4valelemsecondfirst = VLDataset(VL_STRING, false);
19812  if (vlkeys_[VL_STRING].count(key4valelemsecondfirst) != 1) {
19813  AppendVLKey(keysds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst);
19814  InsertVLVal(valsds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst, it1val->second.first);
19815  }
19816  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0, key4valelemsecondfirst.val, CYCLUS_SHA1_SIZE);
19817  valuelen4valelemsecondsecond=std::min(it1val->second.second.size(), item_size4valelemsecondsecond);
19818  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst, it1val->second.second.c_str(), valuelen4valelemsecondsecond);
19819  memset(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst+valuelen4valelemsecondsecond, 0, item_size4valelemsecondsecond-valuelen4valelemsecondsecond);
19820  ++count1val;
19821 
19822  }
19823  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19824  ++count0;
19825 
19826  }
19827  if(total_item_size0*length0<column){
19828  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19829 
19830  }
19831 }
19832 template<>
19833 void Hdf5Back::WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19834  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
19835  size_t item_size0=((shape[1]+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
19836  size_t length0=shape[0];
19837  size_t item_size1key=shape[1];
19838  size_t valuelen1key;
19839  size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]);
19840  size_t length1val=shape[2];
19841  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
19842  size_t item_size3valelemfirst=sizeof(int);
19843  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
19844  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
19845  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
19846  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19847  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19848  size_t total_item_size1val=item_size2valelem;
19849  size_t total_item_size0=item_size1key+item_size1val;
19850  if(total_item_size0*val0.size()>column){
19851  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19852  std::advance(eraseit, column/total_item_size0);
19853  val0.erase(eraseit,val0.end());
19854 
19855  }
19856  unsigned int count0=0;
19857  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19858  for(;it0!=val0.end();++it0){
19859  valuelen1key=std::min(it0->first.size(), item_size1key);
19860  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19861  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19862  unsigned int count1val=0;
19863  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19864  for(;it1val!=it0->second.end();++it1val){
19865  unsigned int count2valelem=0;
19866  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
19867  unsigned int count3valelemsecond=0;
19868  hasher_.Clear();
19869  hasher_.Update(it1val->second.first);
19870  Digest key4valelemsecondfirst = hasher_.digest();
19871  hid_t keysds4valelemsecondfirst = VLDataset(VL_STRING, true);
19872  hid_t valsds4valelemsecondfirst = VLDataset(VL_STRING, false);
19873  if (vlkeys_[VL_STRING].count(key4valelemsecondfirst) != 1) {
19874  AppendVLKey(keysds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst);
19875  InsertVLVal(valsds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst, it1val->second.first);
19876  }
19877  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0, key4valelemsecondfirst.val, CYCLUS_SHA1_SIZE);
19878  hasher_.Clear();
19879  hasher_.Update(it1val->second.second);
19880  Digest key4valelemsecondsecond = hasher_.digest();
19881  hid_t keysds4valelemsecondsecond = VLDataset(VL_STRING, true);
19882  hid_t valsds4valelemsecondsecond = VLDataset(VL_STRING, false);
19883  if (vlkeys_[VL_STRING].count(key4valelemsecondsecond) != 1) {
19884  AppendVLKey(keysds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond);
19885  InsertVLVal(valsds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond, it1val->second.second);
19886  }
19887  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst, key4valelemsecondsecond.val, CYCLUS_SHA1_SIZE);
19888  ++count1val;
19889 
19890  }
19891  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
19892  ++count0;
19893 
19894  }
19895  if(total_item_size0*length0<column){
19896  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19897 
19898  }
19899 }
19900 template<>
19901 void Hdf5Back::WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19902  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
19903  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
19904  size_t length0=shape[0];
19905  size_t item_size1key=shape[1];
19906  size_t valuelen1key;
19907  size_t item_size1val=(CYCLUS_SHA1_SIZE);
19908  size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
19909  size_t item_size3valelemfirst=sizeof(int);
19910  size_t item_size3valelemsecond=((shape[6]+shape[7]));
19911  size_t item_size4valelemsecondfirst=shape[6];
19912  size_t valuelen4valelemsecondfirst;
19913  size_t item_size4valelemsecondsecond=shape[7];
19914  size_t valuelen4valelemsecondsecond;
19915  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19916  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19917  size_t total_item_size1val=item_size2valelem;
19918  size_t total_item_size0=item_size1key+item_size1val;
19919  if(total_item_size0*val0.size()>column){
19920  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19921  std::advance(eraseit, column/total_item_size0);
19922  val0.erase(eraseit,val0.end());
19923 
19924  }
19925  unsigned int count0=0;
19926  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19927  for(;it0!=val0.end();++it0){
19928  valuelen1key=std::min(it0->first.size(), item_size1key);
19929  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19930  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19931  unsigned int count1val=0;
19932  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19933  std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
19934  unsigned int pad_count1val=0;
19935  for(;it1val!=it0->second.end();++it1val){
19936  std::pair<int, std::pair<std::string, std::string>> child2valelem;
19937  unsigned int pad_count2valelem=0;
19938  std::pair<std::string, std::string> child3valelemsecond;
19939  unsigned int pad_count3valelemsecond=0;
19940  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
19941  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
19942  child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
19943  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
19944  fixed_val1val.push_back(child2valelem);
19945  ++pad_count1val;
19946 
19947  }
19948  hasher_.Clear();
19949  hasher_.Update(fixed_val1val);
19950  Digest key1val = hasher_.digest();
19951  hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
19952  hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
19953  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key1val) != 1) {
19954  hvl_t buf1val = VLValToBuf(fixed_val1val);
19955  AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key1val);
19956  InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key1val, buf1val);
19957  }
19958  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
19959  ++count0;
19960 
19961  }
19962  if(total_item_size0*length0<column){
19963  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
19964 
19965  }
19966 }
19967 template<>
19968 void Hdf5Back::WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
19969  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
19970  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
19971  size_t length0=shape[0];
19972  size_t item_size1key=shape[1];
19973  size_t valuelen1key;
19974  size_t item_size1val=(CYCLUS_SHA1_SIZE);
19975  size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
19976  size_t item_size3valelemfirst=sizeof(int);
19977  size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
19978  size_t item_size4valelemsecondfirst=shape[6];
19979  size_t valuelen4valelemsecondfirst;
19980  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
19981  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
19982  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
19983  size_t total_item_size1val=item_size2valelem;
19984  size_t total_item_size0=item_size1key+item_size1val;
19985  if(total_item_size0*val0.size()>column){
19986  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
19987  std::advance(eraseit, column/total_item_size0);
19988  val0.erase(eraseit,val0.end());
19989 
19990  }
19991  unsigned int count0=0;
19992  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
19993  for(;it0!=val0.end();++it0){
19994  valuelen1key=std::min(it0->first.size(), item_size1key);
19995  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
19996  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
19997  unsigned int count1val=0;
19998  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
19999  std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
20000  unsigned int pad_count1val=0;
20001  for(;it1val!=it0->second.end();++it1val){
20002  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20003  unsigned int pad_count2valelem=0;
20004  std::pair<std::string, std::string> child3valelemsecond;
20005  unsigned int pad_count3valelemsecond=0;
20006  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20007  child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
20008  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20009  fixed_val1val.push_back(child2valelem);
20010  ++pad_count1val;
20011 
20012  }
20013  hasher_.Clear();
20014  hasher_.Update(fixed_val1val);
20015  Digest key1val = hasher_.digest();
20016  hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
20017  hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
20018  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key1val) != 1) {
20019  hvl_t buf1val = VLValToBuf(fixed_val1val);
20020  AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key1val);
20021  InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key1val, buf1val);
20022  }
20023  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
20024  ++count0;
20025 
20026  }
20027  if(total_item_size0*length0<column){
20028  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20029 
20030  }
20031 }
20032 template<>
20033 void Hdf5Back::WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20034  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20035  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
20036  size_t length0=shape[0];
20037  size_t item_size1key=shape[1];
20038  size_t valuelen1key;
20039  size_t item_size1val=(CYCLUS_SHA1_SIZE);
20040  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
20041  size_t item_size3valelemfirst=sizeof(int);
20042  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
20043  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20044  size_t item_size4valelemsecondsecond=shape[7];
20045  size_t valuelen4valelemsecondsecond;
20046  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20047  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20048  size_t total_item_size1val=item_size2valelem;
20049  size_t total_item_size0=item_size1key+item_size1val;
20050  if(total_item_size0*val0.size()>column){
20051  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20052  std::advance(eraseit, column/total_item_size0);
20053  val0.erase(eraseit,val0.end());
20054 
20055  }
20056  unsigned int count0=0;
20057  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20058  for(;it0!=val0.end();++it0){
20059  valuelen1key=std::min(it0->first.size(), item_size1key);
20060  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
20061  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
20062  unsigned int count1val=0;
20063  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20064  std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
20065  unsigned int pad_count1val=0;
20066  for(;it1val!=it0->second.end();++it1val){
20067  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20068  unsigned int pad_count2valelem=0;
20069  std::pair<std::string, std::string> child3valelemsecond;
20070  unsigned int pad_count3valelemsecond=0;
20071  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20072  child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
20073  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20074  fixed_val1val.push_back(child2valelem);
20075  ++pad_count1val;
20076 
20077  }
20078  hasher_.Clear();
20079  hasher_.Update(fixed_val1val);
20080  Digest key1val = hasher_.digest();
20081  hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
20082  hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
20083  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key1val) != 1) {
20084  hvl_t buf1val = VLValToBuf(fixed_val1val);
20085  AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key1val);
20086  InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key1val, buf1val);
20087  }
20088  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
20089  ++count0;
20090 
20091  }
20092  if(total_item_size0*length0<column){
20093  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20094 
20095  }
20096 }
20097 template<>
20098 void Hdf5Back::WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20099  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20100  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
20101  size_t length0=shape[0];
20102  size_t item_size1key=shape[1];
20103  size_t valuelen1key;
20104  size_t item_size1val=(CYCLUS_SHA1_SIZE);
20105  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
20106  size_t item_size3valelemfirst=sizeof(int);
20107  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
20108  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20109  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20110  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20111  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20112  size_t total_item_size1val=item_size2valelem;
20113  size_t total_item_size0=item_size1key+item_size1val;
20114  if(total_item_size0*val0.size()>column){
20115  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20116  std::advance(eraseit, column/total_item_size0);
20117  val0.erase(eraseit,val0.end());
20118 
20119  }
20120  unsigned int count0=0;
20121  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20122  for(;it0!=val0.end();++it0){
20123  valuelen1key=std::min(it0->first.size(), item_size1key);
20124  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
20125  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
20126  hasher_.Clear();
20127  hasher_.Update(it0->second);
20128  Digest key1val = hasher_.digest();
20129  hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
20130  hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
20131  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key1val) != 1) {
20132  hvl_t buf1val = VLValToBuf(it0->second);
20133  AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val);
20134  InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val, buf1val);
20135  }
20136  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
20137  ++count0;
20138 
20139  }
20140  if(total_item_size0*length0<column){
20141  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20142 
20143  }
20144 }
20145 template<>
20146 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20147  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20148  size_t item_size0=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]))*shape[0]);
20149  size_t length0=shape[0];
20150  size_t item_size1key=CYCLUS_SHA1_SIZE;
20151  size_t item_size1val=((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]);
20152  size_t length1val=shape[2];
20153  size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
20154  size_t item_size3valelemfirst=sizeof(int);
20155  size_t item_size3valelemsecond=((shape[6]+shape[7]));
20156  size_t item_size4valelemsecondfirst=shape[6];
20157  size_t valuelen4valelemsecondfirst;
20158  size_t item_size4valelemsecondsecond=shape[7];
20159  size_t valuelen4valelemsecondsecond;
20160  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20161  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20162  size_t total_item_size1val=item_size2valelem;
20163  size_t total_item_size0=item_size1key+item_size1val;
20164  if(total_item_size0*val0.size()>column){
20165  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20166  std::advance(eraseit, column/total_item_size0);
20167  val0.erase(eraseit,val0.end());
20168 
20169  }
20170  unsigned int count0=0;
20171  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20172  for(;it0!=val0.end();++it0){
20173  hasher_.Clear();
20174  hasher_.Update(it0->first);
20175  Digest key1key = hasher_.digest();
20176  hid_t keysds1key = VLDataset(VL_STRING, true);
20177  hid_t valsds1key = VLDataset(VL_STRING, false);
20178  if (vlkeys_[VL_STRING].count(key1key) != 1) {
20179  AppendVLKey(keysds1key, VL_STRING, key1key);
20180  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20181  }
20182  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
20183  unsigned int count1val=0;
20184  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20185  for(;it1val!=it0->second.end();++it1val){
20186  unsigned int count2valelem=0;
20187  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
20188  unsigned int count3valelemsecond=0;
20189  valuelen4valelemsecondfirst=std::min(it1val->second.first.size(), item_size4valelemsecondfirst);
20190  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0, it1val->second.first.c_str(), valuelen4valelemsecondfirst);
20191  memset(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+valuelen4valelemsecondfirst, 0, item_size4valelemsecondfirst-valuelen4valelemsecondfirst);
20192  valuelen4valelemsecondsecond=std::min(it1val->second.second.size(), item_size4valelemsecondsecond);
20193  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst, it1val->second.second.c_str(), valuelen4valelemsecondsecond);
20194  memset(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst+valuelen4valelemsecondsecond, 0, item_size4valelemsecondsecond-valuelen4valelemsecondsecond);
20195  ++count1val;
20196 
20197  }
20198  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
20199  ++count0;
20200 
20201  }
20202  if(total_item_size0*length0<column){
20203  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20204 
20205  }
20206 }
20207 template<>
20208 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20209  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20210  size_t item_size0=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
20211  size_t length0=shape[0];
20212  size_t item_size1key=CYCLUS_SHA1_SIZE;
20213  size_t item_size1val=((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]);
20214  size_t length1val=shape[2];
20215  size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
20216  size_t item_size3valelemfirst=sizeof(int);
20217  size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
20218  size_t item_size4valelemsecondfirst=shape[6];
20219  size_t valuelen4valelemsecondfirst;
20220  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20221  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20222  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20223  size_t total_item_size1val=item_size2valelem;
20224  size_t total_item_size0=item_size1key+item_size1val;
20225  if(total_item_size0*val0.size()>column){
20226  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20227  std::advance(eraseit, column/total_item_size0);
20228  val0.erase(eraseit,val0.end());
20229 
20230  }
20231  unsigned int count0=0;
20232  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20233  for(;it0!=val0.end();++it0){
20234  hasher_.Clear();
20235  hasher_.Update(it0->first);
20236  Digest key1key = hasher_.digest();
20237  hid_t keysds1key = VLDataset(VL_STRING, true);
20238  hid_t valsds1key = VLDataset(VL_STRING, false);
20239  if (vlkeys_[VL_STRING].count(key1key) != 1) {
20240  AppendVLKey(keysds1key, VL_STRING, key1key);
20241  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20242  }
20243  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
20244  unsigned int count1val=0;
20245  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20246  for(;it1val!=it0->second.end();++it1val){
20247  unsigned int count2valelem=0;
20248  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
20249  unsigned int count3valelemsecond=0;
20250  valuelen4valelemsecondfirst=std::min(it1val->second.first.size(), item_size4valelemsecondfirst);
20251  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0, it1val->second.first.c_str(), valuelen4valelemsecondfirst);
20252  memset(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+valuelen4valelemsecondfirst, 0, item_size4valelemsecondfirst-valuelen4valelemsecondfirst);
20253  hasher_.Clear();
20254  hasher_.Update(it1val->second.second);
20255  Digest key4valelemsecondsecond = hasher_.digest();
20256  hid_t keysds4valelemsecondsecond = VLDataset(VL_STRING, true);
20257  hid_t valsds4valelemsecondsecond = VLDataset(VL_STRING, false);
20258  if (vlkeys_[VL_STRING].count(key4valelemsecondsecond) != 1) {
20259  AppendVLKey(keysds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond);
20260  InsertVLVal(valsds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond, it1val->second.second);
20261  }
20262  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst, key4valelemsecondsecond.val, CYCLUS_SHA1_SIZE);
20263  ++count1val;
20264 
20265  }
20266  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
20267  ++count0;
20268 
20269  }
20270  if(total_item_size0*length0<column){
20271  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20272 
20273  }
20274 }
20275 template<>
20276 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20277  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20278  size_t item_size0=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]))*shape[0]);
20279  size_t length0=shape[0];
20280  size_t item_size1key=CYCLUS_SHA1_SIZE;
20281  size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]);
20282  size_t length1val=shape[2];
20283  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
20284  size_t item_size3valelemfirst=sizeof(int);
20285  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
20286  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20287  size_t item_size4valelemsecondsecond=shape[7];
20288  size_t valuelen4valelemsecondsecond;
20289  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20290  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20291  size_t total_item_size1val=item_size2valelem;
20292  size_t total_item_size0=item_size1key+item_size1val;
20293  if(total_item_size0*val0.size()>column){
20294  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20295  std::advance(eraseit, column/total_item_size0);
20296  val0.erase(eraseit,val0.end());
20297 
20298  }
20299  unsigned int count0=0;
20300  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20301  for(;it0!=val0.end();++it0){
20302  hasher_.Clear();
20303  hasher_.Update(it0->first);
20304  Digest key1key = hasher_.digest();
20305  hid_t keysds1key = VLDataset(VL_STRING, true);
20306  hid_t valsds1key = VLDataset(VL_STRING, false);
20307  if (vlkeys_[VL_STRING].count(key1key) != 1) {
20308  AppendVLKey(keysds1key, VL_STRING, key1key);
20309  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20310  }
20311  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
20312  unsigned int count1val=0;
20313  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20314  for(;it1val!=it0->second.end();++it1val){
20315  unsigned int count2valelem=0;
20316  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
20317  unsigned int count3valelemsecond=0;
20318  hasher_.Clear();
20319  hasher_.Update(it1val->second.first);
20320  Digest key4valelemsecondfirst = hasher_.digest();
20321  hid_t keysds4valelemsecondfirst = VLDataset(VL_STRING, true);
20322  hid_t valsds4valelemsecondfirst = VLDataset(VL_STRING, false);
20323  if (vlkeys_[VL_STRING].count(key4valelemsecondfirst) != 1) {
20324  AppendVLKey(keysds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst);
20325  InsertVLVal(valsds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst, it1val->second.first);
20326  }
20327  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0, key4valelemsecondfirst.val, CYCLUS_SHA1_SIZE);
20328  valuelen4valelemsecondsecond=std::min(it1val->second.second.size(), item_size4valelemsecondsecond);
20329  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst, it1val->second.second.c_str(), valuelen4valelemsecondsecond);
20330  memset(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst+valuelen4valelemsecondsecond, 0, item_size4valelemsecondsecond-valuelen4valelemsecondsecond);
20331  ++count1val;
20332 
20333  }
20334  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
20335  ++count0;
20336 
20337  }
20338  if(total_item_size0*length0<column){
20339  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20340 
20341  }
20342 }
20343 template<>
20344 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20345  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20346  size_t item_size0=((CYCLUS_SHA1_SIZE+((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]))*shape[0]);
20347  size_t length0=shape[0];
20348  size_t item_size1key=CYCLUS_SHA1_SIZE;
20349  size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]);
20350  size_t length1val=shape[2];
20351  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
20352  size_t item_size3valelemfirst=sizeof(int);
20353  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
20354  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20355  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20356  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20357  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20358  size_t total_item_size1val=item_size2valelem;
20359  size_t total_item_size0=item_size1key+item_size1val;
20360  if(total_item_size0*val0.size()>column){
20361  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20362  std::advance(eraseit, column/total_item_size0);
20363  val0.erase(eraseit,val0.end());
20364 
20365  }
20366  unsigned int count0=0;
20367  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20368  for(;it0!=val0.end();++it0){
20369  hasher_.Clear();
20370  hasher_.Update(it0->first);
20371  Digest key1key = hasher_.digest();
20372  hid_t keysds1key = VLDataset(VL_STRING, true);
20373  hid_t valsds1key = VLDataset(VL_STRING, false);
20374  if (vlkeys_[VL_STRING].count(key1key) != 1) {
20375  AppendVLKey(keysds1key, VL_STRING, key1key);
20376  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20377  }
20378  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
20379  unsigned int count1val=0;
20380  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20381  for(;it1val!=it0->second.end();++it1val){
20382  unsigned int count2valelem=0;
20383  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0, &(it1val->first), item_size3valelemfirst);
20384  unsigned int count3valelemsecond=0;
20385  hasher_.Clear();
20386  hasher_.Update(it1val->second.first);
20387  Digest key4valelemsecondfirst = hasher_.digest();
20388  hid_t keysds4valelemsecondfirst = VLDataset(VL_STRING, true);
20389  hid_t valsds4valelemsecondfirst = VLDataset(VL_STRING, false);
20390  if (vlkeys_[VL_STRING].count(key4valelemsecondfirst) != 1) {
20391  AppendVLKey(keysds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst);
20392  InsertVLVal(valsds4valelemsecondfirst, VL_STRING, key4valelemsecondfirst, it1val->second.first);
20393  }
20394  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0, key4valelemsecondfirst.val, CYCLUS_SHA1_SIZE);
20395  hasher_.Clear();
20396  hasher_.Update(it1val->second.second);
20397  Digest key4valelemsecondsecond = hasher_.digest();
20398  hid_t keysds4valelemsecondsecond = VLDataset(VL_STRING, true);
20399  hid_t valsds4valelemsecondsecond = VLDataset(VL_STRING, false);
20400  if (vlkeys_[VL_STRING].count(key4valelemsecondsecond) != 1) {
20401  AppendVLKey(keysds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond);
20402  InsertVLVal(valsds4valelemsecondsecond, VL_STRING, key4valelemsecondsecond, it1val->second.second);
20403  }
20404  memcpy(buf+(count0*total_item_size0)+0+item_size1key+item_size2valelem*count1val+(count2valelem*total_item_size2valelem)+0+item_size3valelemfirst+(count3valelemsecond*total_item_size3valelemsecond)+0+item_size4valelemsecondfirst, key4valelemsecondsecond.val, CYCLUS_SHA1_SIZE);
20405  ++count1val;
20406 
20407  }
20408  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
20409  ++count0;
20410 
20411  }
20412  if(total_item_size0*length0<column){
20413  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20414 
20415  }
20416 }
20417 template<>
20418 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20419  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20420  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
20421  size_t length0=shape[0];
20422  size_t item_size1key=CYCLUS_SHA1_SIZE;
20423  size_t item_size1val=(CYCLUS_SHA1_SIZE);
20424  size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
20425  size_t item_size3valelemfirst=sizeof(int);
20426  size_t item_size3valelemsecond=((shape[6]+shape[7]));
20427  size_t item_size4valelemsecondfirst=shape[6];
20428  size_t valuelen4valelemsecondfirst;
20429  size_t item_size4valelemsecondsecond=shape[7];
20430  size_t valuelen4valelemsecondsecond;
20431  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20432  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20433  size_t total_item_size1val=item_size2valelem;
20434  size_t total_item_size0=item_size1key+item_size1val;
20435  if(total_item_size0*val0.size()>column){
20436  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20437  std::advance(eraseit, column/total_item_size0);
20438  val0.erase(eraseit,val0.end());
20439 
20440  }
20441  unsigned int count0=0;
20442  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20443  for(;it0!=val0.end();++it0){
20444  hasher_.Clear();
20445  hasher_.Update(it0->first);
20446  Digest key1key = hasher_.digest();
20447  hid_t keysds1key = VLDataset(VL_STRING, true);
20448  hid_t valsds1key = VLDataset(VL_STRING, false);
20449  if (vlkeys_[VL_STRING].count(key1key) != 1) {
20450  AppendVLKey(keysds1key, VL_STRING, key1key);
20451  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20452  }
20453  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
20454  unsigned int count1val=0;
20455  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20456  std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
20457  unsigned int pad_count1val=0;
20458  for(;it1val!=it0->second.end();++it1val){
20459  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20460  unsigned int pad_count2valelem=0;
20461  std::pair<std::string, std::string> child3valelemsecond;
20462  unsigned int pad_count3valelemsecond=0;
20463  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20464  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20465  child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
20466  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20467  fixed_val1val.push_back(child2valelem);
20468  ++pad_count1val;
20469 
20470  }
20471  hasher_.Clear();
20472  hasher_.Update(fixed_val1val);
20473  Digest key1val = hasher_.digest();
20474  hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
20475  hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
20476  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key1val) != 1) {
20477  hvl_t buf1val = VLValToBuf(fixed_val1val);
20478  AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key1val);
20479  InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key1val, buf1val);
20480  }
20481  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
20482  ++count0;
20483 
20484  }
20485  if(total_item_size0*length0<column){
20486  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20487 
20488  }
20489 }
20490 template<>
20491 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20492  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20493  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
20494  size_t length0=shape[0];
20495  size_t item_size1key=CYCLUS_SHA1_SIZE;
20496  size_t item_size1val=(CYCLUS_SHA1_SIZE);
20497  size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
20498  size_t item_size3valelemfirst=sizeof(int);
20499  size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
20500  size_t item_size4valelemsecondfirst=shape[6];
20501  size_t valuelen4valelemsecondfirst;
20502  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20503  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20504  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20505  size_t total_item_size1val=item_size2valelem;
20506  size_t total_item_size0=item_size1key+item_size1val;
20507  if(total_item_size0*val0.size()>column){
20508  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20509  std::advance(eraseit, column/total_item_size0);
20510  val0.erase(eraseit,val0.end());
20511 
20512  }
20513  unsigned int count0=0;
20514  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20515  for(;it0!=val0.end();++it0){
20516  hasher_.Clear();
20517  hasher_.Update(it0->first);
20518  Digest key1key = hasher_.digest();
20519  hid_t keysds1key = VLDataset(VL_STRING, true);
20520  hid_t valsds1key = VLDataset(VL_STRING, false);
20521  if (vlkeys_[VL_STRING].count(key1key) != 1) {
20522  AppendVLKey(keysds1key, VL_STRING, key1key);
20523  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20524  }
20525  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
20526  unsigned int count1val=0;
20527  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20528  std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
20529  unsigned int pad_count1val=0;
20530  for(;it1val!=it0->second.end();++it1val){
20531  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20532  unsigned int pad_count2valelem=0;
20533  std::pair<std::string, std::string> child3valelemsecond;
20534  unsigned int pad_count3valelemsecond=0;
20535  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20536  child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
20537  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20538  fixed_val1val.push_back(child2valelem);
20539  ++pad_count1val;
20540 
20541  }
20542  hasher_.Clear();
20543  hasher_.Update(fixed_val1val);
20544  Digest key1val = hasher_.digest();
20545  hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
20546  hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
20547  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key1val) != 1) {
20548  hvl_t buf1val = VLValToBuf(fixed_val1val);
20549  AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key1val);
20550  InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key1val, buf1val);
20551  }
20552  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
20553  ++count0;
20554 
20555  }
20556  if(total_item_size0*length0<column){
20557  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20558 
20559  }
20560 }
20561 template<>
20562 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20563  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20564  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
20565  size_t length0=shape[0];
20566  size_t item_size1key=CYCLUS_SHA1_SIZE;
20567  size_t item_size1val=(CYCLUS_SHA1_SIZE);
20568  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
20569  size_t item_size3valelemfirst=sizeof(int);
20570  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
20571  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20572  size_t item_size4valelemsecondsecond=shape[7];
20573  size_t valuelen4valelemsecondsecond;
20574  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20575  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20576  size_t total_item_size1val=item_size2valelem;
20577  size_t total_item_size0=item_size1key+item_size1val;
20578  if(total_item_size0*val0.size()>column){
20579  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20580  std::advance(eraseit, column/total_item_size0);
20581  val0.erase(eraseit,val0.end());
20582 
20583  }
20584  unsigned int count0=0;
20585  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20586  for(;it0!=val0.end();++it0){
20587  hasher_.Clear();
20588  hasher_.Update(it0->first);
20589  Digest key1key = hasher_.digest();
20590  hid_t keysds1key = VLDataset(VL_STRING, true);
20591  hid_t valsds1key = VLDataset(VL_STRING, false);
20592  if (vlkeys_[VL_STRING].count(key1key) != 1) {
20593  AppendVLKey(keysds1key, VL_STRING, key1key);
20594  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20595  }
20596  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
20597  unsigned int count1val=0;
20598  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20599  std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val1val;
20600  unsigned int pad_count1val=0;
20601  for(;it1val!=it0->second.end();++it1val){
20602  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20603  unsigned int pad_count2valelem=0;
20604  std::pair<std::string, std::string> child3valelemsecond;
20605  unsigned int pad_count3valelemsecond=0;
20606  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20607  child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
20608  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20609  fixed_val1val.push_back(child2valelem);
20610  ++pad_count1val;
20611 
20612  }
20613  hasher_.Clear();
20614  hasher_.Update(fixed_val1val);
20615  Digest key1val = hasher_.digest();
20616  hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
20617  hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
20618  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key1val) != 1) {
20619  hvl_t buf1val = VLValToBuf(fixed_val1val);
20620  AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key1val);
20621  InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key1val, buf1val);
20622  }
20623  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
20624  ++count0;
20625 
20626  }
20627  if(total_item_size0*length0<column){
20628  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20629 
20630  }
20631 }
20632 template<>
20633 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20634  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20635  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
20636  size_t length0=shape[0];
20637  size_t item_size1key=CYCLUS_SHA1_SIZE;
20638  size_t item_size1val=(CYCLUS_SHA1_SIZE);
20639  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
20640  size_t item_size3valelemfirst=sizeof(int);
20641  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
20642  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20643  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20644  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20645  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20646  size_t total_item_size1val=item_size2valelem;
20647  size_t total_item_size0=item_size1key+item_size1val;
20648  if(total_item_size0*val0.size()>column){
20649  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator eraseit=val0.begin();
20650  std::advance(eraseit, column/total_item_size0);
20651  val0.erase(eraseit,val0.end());
20652 
20653  }
20654  unsigned int count0=0;
20655  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20656  for(;it0!=val0.end();++it0){
20657  hasher_.Clear();
20658  hasher_.Update(it0->first);
20659  Digest key1key = hasher_.digest();
20660  hid_t keysds1key = VLDataset(VL_STRING, true);
20661  hid_t valsds1key = VLDataset(VL_STRING, false);
20662  if (vlkeys_[VL_STRING].count(key1key) != 1) {
20663  AppendVLKey(keysds1key, VL_STRING, key1key);
20664  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
20665  }
20666  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
20667  hasher_.Clear();
20668  hasher_.Update(it0->second);
20669  Digest key1val = hasher_.digest();
20670  hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
20671  hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
20672  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key1val) != 1) {
20673  hvl_t buf1val = VLValToBuf(it0->second);
20674  AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val);
20675  InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val, buf1val);
20676  }
20677  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
20678  ++count0;
20679 
20680  }
20681  if(total_item_size0*length0<column){
20682  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
20683 
20684  }
20685 }
20686 template<>
20687 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20688  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20689  size_t item_size0=(CYCLUS_SHA1_SIZE);
20690  size_t item_size1key=shape[1];
20691  size_t valuelen1key;
20692  size_t item_size1val=((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]);
20693  size_t length1val=shape[2];
20694  size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
20695  size_t item_size3valelemfirst=sizeof(int);
20696  size_t item_size3valelemsecond=((shape[6]+shape[7]));
20697  size_t item_size4valelemsecondfirst=shape[6];
20698  size_t valuelen4valelemsecondfirst;
20699  size_t item_size4valelemsecondsecond=shape[7];
20700  size_t valuelen4valelemsecondsecond;
20701  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20702  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20703  size_t total_item_size1val=item_size2valelem;
20704  size_t total_item_size0=item_size1key+item_size1val;
20705  unsigned int count0=0;
20706  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20707  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20708  unsigned int pad_count0=0;
20709  for(;it0!=val0.end();++it0){
20710  std::string child1key=std::string(it0->first,0,item_size1key);
20711  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20712  unsigned int pad_count1val=0;
20713  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20714  for(;it1val!=it0->second.end();++it1val){
20715  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20716  unsigned int pad_count2valelem=0;
20717  std::pair<std::string, std::string> child3valelemsecond;
20718  unsigned int pad_count3valelemsecond=0;
20719  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20720  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20721  child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
20722  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20723  child1val.push_back(child2valelem);
20724  ++pad_count1val;
20725 
20726  }
20727  child1val.resize(length1val);
20728  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
20729  fixed_val0[child1key] = child1val;
20730  ++pad_count0;
20731 
20732  }
20733  hasher_.Clear();
20734  hasher_.Update(fixed_val0);
20735  Digest key0 = hasher_.digest();
20736  hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
20737  hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
20738  if (vlkeys_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
20739  hvl_t buf0 = VLValToBuf(fixed_val0);
20740  AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
20741  InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
20742  }
20743  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
20744 }
20745 template<>
20746 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20747  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20748  size_t item_size0=(CYCLUS_SHA1_SIZE);
20749  size_t item_size1key=shape[1];
20750  size_t valuelen1key;
20751  size_t item_size1val=((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]);
20752  size_t length1val=shape[2];
20753  size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
20754  size_t item_size3valelemfirst=sizeof(int);
20755  size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
20756  size_t item_size4valelemsecondfirst=shape[6];
20757  size_t valuelen4valelemsecondfirst;
20758  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20759  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20760  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20761  size_t total_item_size1val=item_size2valelem;
20762  size_t total_item_size0=item_size1key+item_size1val;
20763  unsigned int count0=0;
20764  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20765  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20766  unsigned int pad_count0=0;
20767  for(;it0!=val0.end();++it0){
20768  std::string child1key=std::string(it0->first,0,item_size1key);
20769  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20770  unsigned int pad_count1val=0;
20771  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20772  for(;it1val!=it0->second.end();++it1val){
20773  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20774  unsigned int pad_count2valelem=0;
20775  std::pair<std::string, std::string> child3valelemsecond;
20776  unsigned int pad_count3valelemsecond=0;
20777  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20778  child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
20779  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20780  child1val.push_back(child2valelem);
20781  ++pad_count1val;
20782 
20783  }
20784  child1val.resize(length1val);
20785  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
20786  fixed_val0[child1key] = child1val;
20787  ++pad_count0;
20788 
20789  }
20790  hasher_.Clear();
20791  hasher_.Update(fixed_val0);
20792  Digest key0 = hasher_.digest();
20793  hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
20794  hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
20795  if (vlkeys_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
20796  hvl_t buf0 = VLValToBuf(fixed_val0);
20797  AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0);
20798  InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
20799  }
20800  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
20801 }
20802 template<>
20803 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20804  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20805  size_t item_size0=(CYCLUS_SHA1_SIZE);
20806  size_t item_size1key=shape[1];
20807  size_t valuelen1key;
20808  size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]);
20809  size_t length1val=shape[2];
20810  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
20811  size_t item_size3valelemfirst=sizeof(int);
20812  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
20813  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20814  size_t item_size4valelemsecondsecond=shape[7];
20815  size_t valuelen4valelemsecondsecond;
20816  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20817  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20818  size_t total_item_size1val=item_size2valelem;
20819  size_t total_item_size0=item_size1key+item_size1val;
20820  unsigned int count0=0;
20821  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20822  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20823  unsigned int pad_count0=0;
20824  for(;it0!=val0.end();++it0){
20825  std::string child1key=std::string(it0->first,0,item_size1key);
20826  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20827  unsigned int pad_count1val=0;
20828  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20829  for(;it1val!=it0->second.end();++it1val){
20830  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20831  unsigned int pad_count2valelem=0;
20832  std::pair<std::string, std::string> child3valelemsecond;
20833  unsigned int pad_count3valelemsecond=0;
20834  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20835  child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
20836  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20837  child1val.push_back(child2valelem);
20838  ++pad_count1val;
20839 
20840  }
20841  child1val.resize(length1val);
20842  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
20843  fixed_val0[child1key] = child1val;
20844  ++pad_count0;
20845 
20846  }
20847  hasher_.Clear();
20848  hasher_.Update(fixed_val0);
20849  Digest key0 = hasher_.digest();
20850  hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
20851  hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
20852  if (vlkeys_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
20853  hvl_t buf0 = VLValToBuf(fixed_val0);
20854  AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0);
20855  InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
20856  }
20857  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
20858 }
20859 template<>
20860 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20861  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20862  size_t item_size0=(CYCLUS_SHA1_SIZE);
20863  size_t item_size1key=shape[1];
20864  size_t valuelen1key;
20865  size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]);
20866  size_t length1val=shape[2];
20867  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
20868  size_t item_size3valelemfirst=sizeof(int);
20869  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
20870  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
20871  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20872  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20873  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20874  size_t total_item_size1val=item_size2valelem;
20875  size_t total_item_size0=item_size1key+item_size1val;
20876  unsigned int count0=0;
20877  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20878  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20879  unsigned int pad_count0=0;
20880  for(;it0!=val0.end();++it0){
20881  std::string child1key=std::string(it0->first,0,item_size1key);
20882  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20883  unsigned int pad_count1val=0;
20884  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20885  for(;it1val!=it0->second.end();++it1val){
20886  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20887  unsigned int pad_count2valelem=0;
20888  std::pair<std::string, std::string> child3valelemsecond;
20889  unsigned int pad_count3valelemsecond=0;
20890  child3valelemsecond = std::make_pair((*it1val).second.first,(*it1val).second.second);
20891  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20892  child1val.push_back(child2valelem);
20893  ++pad_count1val;
20894 
20895  }
20896  child1val.resize(length1val);
20897  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
20898  fixed_val0[child1key] = child1val;
20899  ++pad_count0;
20900 
20901  }
20902  hasher_.Clear();
20903  hasher_.Update(fixed_val0);
20904  Digest key0 = hasher_.digest();
20905  hid_t keysds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
20906  hid_t valsds0 = VLDataset(VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
20907  if (vlkeys_[VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
20908  hvl_t buf0 = VLValToBuf(fixed_val0);
20909  AppendVLKey(keysds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0);
20910  InsertVLVal(valsds0, VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
20911  }
20912  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
20913 }
20914 template<>
20915 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20916  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20917  size_t item_size0=(CYCLUS_SHA1_SIZE);
20918  size_t item_size1key=shape[1];
20919  size_t valuelen1key;
20920  size_t item_size1val=(CYCLUS_SHA1_SIZE);
20921  size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
20922  size_t item_size3valelemfirst=sizeof(int);
20923  size_t item_size3valelemsecond=((shape[6]+shape[7]));
20924  size_t item_size4valelemsecondfirst=shape[6];
20925  size_t valuelen4valelemsecondfirst;
20926  size_t item_size4valelemsecondsecond=shape[7];
20927  size_t valuelen4valelemsecondsecond;
20928  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20929  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20930  size_t total_item_size1val=item_size2valelem;
20931  size_t total_item_size0=item_size1key+item_size1val;
20932  unsigned int count0=0;
20933  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20934  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20935  unsigned int pad_count0=0;
20936  for(;it0!=val0.end();++it0){
20937  std::string child1key=std::string(it0->first,0,item_size1key);
20938  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20939  unsigned int pad_count1val=0;
20940  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20941  for(;it1val!=it0->second.end();++it1val){
20942  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20943  unsigned int pad_count2valelem=0;
20944  std::pair<std::string, std::string> child3valelemsecond;
20945  unsigned int pad_count3valelemsecond=0;
20946  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
20947  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
20948  child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
20949  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
20950  child1val.push_back(child2valelem);
20951  ++pad_count1val;
20952 
20953  }
20954  fixed_val0[child1key] = child1val;
20955  ++pad_count0;
20956 
20957  }
20958  hasher_.Clear();
20959  hasher_.Update(fixed_val0);
20960  Digest key0 = hasher_.digest();
20961  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
20962  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
20963  if (vlkeys_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
20964  hvl_t buf0 = VLValToBuf(fixed_val0);
20965  AppendVLKey(keysds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
20966  InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
20967  }
20968  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
20969 }
20970 template<>
20971 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
20972  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
20973  size_t item_size0=(CYCLUS_SHA1_SIZE);
20974  size_t item_size1key=shape[1];
20975  size_t valuelen1key;
20976  size_t item_size1val=(CYCLUS_SHA1_SIZE);
20977  size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
20978  size_t item_size3valelemfirst=sizeof(int);
20979  size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
20980  size_t item_size4valelemsecondfirst=shape[6];
20981  size_t valuelen4valelemsecondfirst;
20982  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
20983  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
20984  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
20985  size_t total_item_size1val=item_size2valelem;
20986  size_t total_item_size0=item_size1key+item_size1val;
20987  unsigned int count0=0;
20988  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
20989  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
20990  unsigned int pad_count0=0;
20991  for(;it0!=val0.end();++it0){
20992  std::string child1key=std::string(it0->first,0,item_size1key);
20993  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
20994  unsigned int pad_count1val=0;
20995  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
20996  for(;it1val!=it0->second.end();++it1val){
20997  std::pair<int, std::pair<std::string, std::string>> child2valelem;
20998  unsigned int pad_count2valelem=0;
20999  std::pair<std::string, std::string> child3valelemsecond;
21000  unsigned int pad_count3valelemsecond=0;
21001  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21002  child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
21003  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21004  child1val.push_back(child2valelem);
21005  ++pad_count1val;
21006 
21007  }
21008  fixed_val0[child1key] = child1val;
21009  ++pad_count0;
21010 
21011  }
21012  hasher_.Clear();
21013  hasher_.Update(fixed_val0);
21014  Digest key0 = hasher_.digest();
21015  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
21016  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
21017  if (vlkeys_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
21018  hvl_t buf0 = VLValToBuf(fixed_val0);
21019  AppendVLKey(keysds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0);
21020  InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
21021  }
21022  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21023 }
21024 template<>
21025 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21026  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21027  size_t item_size0=(CYCLUS_SHA1_SIZE);
21028  size_t item_size1key=shape[1];
21029  size_t valuelen1key;
21030  size_t item_size1val=(CYCLUS_SHA1_SIZE);
21031  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
21032  size_t item_size3valelemfirst=sizeof(int);
21033  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
21034  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21035  size_t item_size4valelemsecondsecond=shape[7];
21036  size_t valuelen4valelemsecondsecond;
21037  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21038  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21039  size_t total_item_size1val=item_size2valelem;
21040  size_t total_item_size0=item_size1key+item_size1val;
21041  unsigned int count0=0;
21042  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21043  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21044  unsigned int pad_count0=0;
21045  for(;it0!=val0.end();++it0){
21046  std::string child1key=std::string(it0->first,0,item_size1key);
21047  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21048  unsigned int pad_count1val=0;
21049  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21050  for(;it1val!=it0->second.end();++it1val){
21051  std::pair<int, std::pair<std::string, std::string>> child2valelem;
21052  unsigned int pad_count2valelem=0;
21053  std::pair<std::string, std::string> child3valelemsecond;
21054  unsigned int pad_count3valelemsecond=0;
21055  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21056  child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
21057  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21058  child1val.push_back(child2valelem);
21059  ++pad_count1val;
21060 
21061  }
21062  fixed_val0[child1key] = child1val;
21063  ++pad_count0;
21064 
21065  }
21066  hasher_.Clear();
21067  hasher_.Update(fixed_val0);
21068  Digest key0 = hasher_.digest();
21069  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
21070  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
21071  if (vlkeys_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
21072  hvl_t buf0 = VLValToBuf(fixed_val0);
21073  AppendVLKey(keysds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0);
21074  InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
21075  }
21076  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21077 }
21078 template<>
21079 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21080  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21081  size_t item_size0=(CYCLUS_SHA1_SIZE);
21082  size_t item_size1key=shape[1];
21083  size_t valuelen1key;
21084  size_t item_size1val=(CYCLUS_SHA1_SIZE);
21085  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
21086  size_t item_size3valelemfirst=sizeof(int);
21087  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
21088  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21089  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21090  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21091  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21092  size_t total_item_size1val=item_size2valelem;
21093  size_t total_item_size0=item_size1key+item_size1val;
21094  unsigned int count0=0;
21095  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21096  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21097  unsigned int pad_count0=0;
21098  for(;it0!=val0.end();++it0){
21099  std::string child1key=std::string(it0->first,0,item_size1key);
21100  fixed_val0[child1key] = it0->second;
21101  ++pad_count0;
21102 
21103  }
21104  hasher_.Clear();
21105  hasher_.Update(fixed_val0);
21106  Digest key0 = hasher_.digest();
21107  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
21108  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
21109  if (vlkeys_[VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
21110  hvl_t buf0 = VLValToBuf(fixed_val0);
21112  InsertVLVal(valsds0, VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
21113  }
21114  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21115 }
21116 template<>
21117 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21118  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21119  size_t item_size0=(CYCLUS_SHA1_SIZE);
21120  size_t item_size1key=CYCLUS_SHA1_SIZE;
21121  size_t item_size1val=((((sizeof(int)+((shape[6]+shape[7])))))*shape[2]);
21122  size_t length1val=shape[2];
21123  size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
21124  size_t item_size3valelemfirst=sizeof(int);
21125  size_t item_size3valelemsecond=((shape[6]+shape[7]));
21126  size_t item_size4valelemsecondfirst=shape[6];
21127  size_t valuelen4valelemsecondfirst;
21128  size_t item_size4valelemsecondsecond=shape[7];
21129  size_t valuelen4valelemsecondsecond;
21130  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21131  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21132  size_t total_item_size1val=item_size2valelem;
21133  size_t total_item_size0=item_size1key+item_size1val;
21134  unsigned int count0=0;
21135  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21136  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21137  unsigned int pad_count0=0;
21138  for(;it0!=val0.end();++it0){
21139  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21140  unsigned int pad_count1val=0;
21141  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21142  for(;it1val!=it0->second.end();++it1val){
21143  std::pair<int, std::pair<std::string, std::string>> child2valelem;
21144  unsigned int pad_count2valelem=0;
21145  std::pair<std::string, std::string> child3valelemsecond;
21146  unsigned int pad_count3valelemsecond=0;
21147  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21148  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21149  child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
21150  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21151  child1val.push_back(child2valelem);
21152  ++pad_count1val;
21153 
21154  }
21155  child1val.resize(length1val);
21156  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
21157  fixed_val0[it0->first] = child1val;
21158  ++pad_count0;
21159 
21160  }
21161  hasher_.Clear();
21162  hasher_.Update(fixed_val0);
21163  Digest key0 = hasher_.digest();
21164  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
21165  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
21166  if (vlkeys_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
21167  hvl_t buf0 = VLValToBuf(fixed_val0);
21168  AppendVLKey(keysds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
21169  InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
21170  }
21171  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21172 }
21173 template<>
21174 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21175  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21176  size_t item_size0=(CYCLUS_SHA1_SIZE);
21177  size_t item_size1key=CYCLUS_SHA1_SIZE;
21178  size_t item_size1val=((((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE)))))*shape[2]);
21179  size_t length1val=shape[2];
21180  size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
21181  size_t item_size3valelemfirst=sizeof(int);
21182  size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
21183  size_t item_size4valelemsecondfirst=shape[6];
21184  size_t valuelen4valelemsecondfirst;
21185  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21186  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21187  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21188  size_t total_item_size1val=item_size2valelem;
21189  size_t total_item_size0=item_size1key+item_size1val;
21190  unsigned int count0=0;
21191  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21192  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21193  unsigned int pad_count0=0;
21194  for(;it0!=val0.end();++it0){
21195  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21196  unsigned int pad_count1val=0;
21197  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21198  for(;it1val!=it0->second.end();++it1val){
21199  std::pair<int, std::pair<std::string, std::string>> child2valelem;
21200  unsigned int pad_count2valelem=0;
21201  std::pair<std::string, std::string> child3valelemsecond;
21202  unsigned int pad_count3valelemsecond=0;
21203  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21204  child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
21205  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21206  child1val.push_back(child2valelem);
21207  ++pad_count1val;
21208 
21209  }
21210  child1val.resize(length1val);
21211  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
21212  fixed_val0[it0->first] = child1val;
21213  ++pad_count0;
21214 
21215  }
21216  hasher_.Clear();
21217  hasher_.Update(fixed_val0);
21218  Digest key0 = hasher_.digest();
21219  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
21220  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
21221  if (vlkeys_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
21222  hvl_t buf0 = VLValToBuf(fixed_val0);
21223  AppendVLKey(keysds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0);
21224  InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
21225  }
21226  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21227 }
21228 template<>
21229 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21230  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21231  size_t item_size0=(CYCLUS_SHA1_SIZE);
21232  size_t item_size1key=CYCLUS_SHA1_SIZE;
21233  size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7])))))*shape[2]);
21234  size_t length1val=shape[2];
21235  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
21236  size_t item_size3valelemfirst=sizeof(int);
21237  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
21238  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21239  size_t item_size4valelemsecondsecond=shape[7];
21240  size_t valuelen4valelemsecondsecond;
21241  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21242  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21243  size_t total_item_size1val=item_size2valelem;
21244  size_t total_item_size0=item_size1key+item_size1val;
21245  unsigned int count0=0;
21246  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21247  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21248  unsigned int pad_count0=0;
21249  for(;it0!=val0.end();++it0){
21250  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21251  unsigned int pad_count1val=0;
21252  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21253  for(;it1val!=it0->second.end();++it1val){
21254  std::pair<int, std::pair<std::string, std::string>> child2valelem;
21255  unsigned int pad_count2valelem=0;
21256  std::pair<std::string, std::string> child3valelemsecond;
21257  unsigned int pad_count3valelemsecond=0;
21258  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21259  child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
21260  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21261  child1val.push_back(child2valelem);
21262  ++pad_count1val;
21263 
21264  }
21265  child1val.resize(length1val);
21266  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
21267  fixed_val0[it0->first] = child1val;
21268  ++pad_count0;
21269 
21270  }
21271  hasher_.Clear();
21272  hasher_.Update(fixed_val0);
21273  Digest key0 = hasher_.digest();
21274  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
21275  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
21276  if (vlkeys_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
21277  hvl_t buf0 = VLValToBuf(fixed_val0);
21278  AppendVLKey(keysds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0);
21279  InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
21280  }
21281  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21282 }
21283 template<>
21284 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21285  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21286  size_t item_size0=(CYCLUS_SHA1_SIZE);
21287  size_t item_size1key=CYCLUS_SHA1_SIZE;
21288  size_t item_size1val=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[2]);
21289  size_t length1val=shape[2];
21290  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
21291  size_t item_size3valelemfirst=sizeof(int);
21292  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
21293  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21294  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21295  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21296  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21297  size_t total_item_size1val=item_size2valelem;
21298  size_t total_item_size0=item_size1key+item_size1val;
21299  unsigned int count0=0;
21300  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21301  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21302  unsigned int pad_count0=0;
21303  for(;it0!=val0.end();++it0){
21304  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21305  unsigned int pad_count1val=0;
21306  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21307  for(;it1val!=it0->second.end();++it1val){
21308  std::pair<int, std::pair<std::string, std::string>> child2valelem;
21309  unsigned int pad_count2valelem=0;
21310  std::pair<std::string, std::string> child3valelemsecond;
21311  unsigned int pad_count3valelemsecond=0;
21312  child3valelemsecond = std::make_pair((*it1val).second.first,(*it1val).second.second);
21313  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21314  child1val.push_back(child2valelem);
21315  ++pad_count1val;
21316 
21317  }
21318  child1val.resize(length1val);
21319  memset(&child1val, 0, (length1val-pad_count1val)*item_size1key);
21320  fixed_val0[it0->first] = child1val;
21321  ++pad_count0;
21322 
21323  }
21324  hasher_.Clear();
21325  hasher_.Update(fixed_val0);
21326  Digest key0 = hasher_.digest();
21327  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
21328  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
21329  if (vlkeys_[VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
21330  hvl_t buf0 = VLValToBuf(fixed_val0);
21332  InsertVLVal(valsds0, VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
21333  }
21334  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21335 }
21336 template<>
21337 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21338  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21339  size_t item_size0=(CYCLUS_SHA1_SIZE);
21340  size_t item_size1key=CYCLUS_SHA1_SIZE;
21341  size_t item_size1val=(CYCLUS_SHA1_SIZE);
21342  size_t item_size2valelem=((sizeof(int)+((shape[6]+shape[7]))));
21343  size_t item_size3valelemfirst=sizeof(int);
21344  size_t item_size3valelemsecond=((shape[6]+shape[7]));
21345  size_t item_size4valelemsecondfirst=shape[6];
21346  size_t valuelen4valelemsecondfirst;
21347  size_t item_size4valelemsecondsecond=shape[7];
21348  size_t valuelen4valelemsecondsecond;
21349  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21350  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21351  size_t total_item_size1val=item_size2valelem;
21352  size_t total_item_size0=item_size1key+item_size1val;
21353  unsigned int count0=0;
21354  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21355  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21356  unsigned int pad_count0=0;
21357  for(;it0!=val0.end();++it0){
21358  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21359  unsigned int pad_count1val=0;
21360  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21361  for(;it1val!=it0->second.end();++it1val){
21362  std::pair<int, std::pair<std::string, std::string>> child2valelem;
21363  unsigned int pad_count2valelem=0;
21364  std::pair<std::string, std::string> child3valelemsecond;
21365  unsigned int pad_count3valelemsecond=0;
21366  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21367  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21368  child3valelemsecond = std::make_pair(child4valelemsecondfirst,child4valelemsecondsecond);
21369  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21370  child1val.push_back(child2valelem);
21371  ++pad_count1val;
21372 
21373  }
21374  fixed_val0[it0->first] = child1val;
21375  ++pad_count0;
21376 
21377  }
21378  hasher_.Clear();
21379  hasher_.Update(fixed_val0);
21380  Digest key0 = hasher_.digest();
21381  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
21382  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
21383  if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
21384  hvl_t buf0 = VLValToBuf(fixed_val0);
21385  AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
21386  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
21387  }
21388  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21389 }
21390 template<>
21391 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21392  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21393  size_t item_size0=(CYCLUS_SHA1_SIZE);
21394  size_t item_size1key=CYCLUS_SHA1_SIZE;
21395  size_t item_size1val=(CYCLUS_SHA1_SIZE);
21396  size_t item_size2valelem=((sizeof(int)+((shape[6]+CYCLUS_SHA1_SIZE))));
21397  size_t item_size3valelemfirst=sizeof(int);
21398  size_t item_size3valelemsecond=((shape[6]+CYCLUS_SHA1_SIZE));
21399  size_t item_size4valelemsecondfirst=shape[6];
21400  size_t valuelen4valelemsecondfirst;
21401  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21402  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21403  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21404  size_t total_item_size1val=item_size2valelem;
21405  size_t total_item_size0=item_size1key+item_size1val;
21406  unsigned int count0=0;
21407  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21408  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21409  unsigned int pad_count0=0;
21410  for(;it0!=val0.end();++it0){
21411  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21412  unsigned int pad_count1val=0;
21413  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21414  for(;it1val!=it0->second.end();++it1val){
21415  std::pair<int, std::pair<std::string, std::string>> child2valelem;
21416  unsigned int pad_count2valelem=0;
21417  std::pair<std::string, std::string> child3valelemsecond;
21418  unsigned int pad_count3valelemsecond=0;
21419  std::string child4valelemsecondfirst=std::string((*it1val).second.first,0,item_size4valelemsecondfirst);
21420  child3valelemsecond = std::make_pair(child4valelemsecondfirst,(*it1val).second.second);
21421  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21422  child1val.push_back(child2valelem);
21423  ++pad_count1val;
21424 
21425  }
21426  fixed_val0[it0->first] = child1val;
21427  ++pad_count0;
21428 
21429  }
21430  hasher_.Clear();
21431  hasher_.Update(fixed_val0);
21432  Digest key0 = hasher_.digest();
21433  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
21434  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
21435  if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
21436  hvl_t buf0 = VLValToBuf(fixed_val0);
21438  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
21439  }
21440  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21441 }
21442 template<>
21443 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21444  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21445  size_t item_size0=(CYCLUS_SHA1_SIZE);
21446  size_t item_size1key=CYCLUS_SHA1_SIZE;
21447  size_t item_size1val=(CYCLUS_SHA1_SIZE);
21448  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[7]))));
21449  size_t item_size3valelemfirst=sizeof(int);
21450  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+shape[7]));
21451  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21452  size_t item_size4valelemsecondsecond=shape[7];
21453  size_t valuelen4valelemsecondsecond;
21454  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21455  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21456  size_t total_item_size1val=item_size2valelem;
21457  size_t total_item_size0=item_size1key+item_size1val;
21458  unsigned int count0=0;
21459  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::iterator it0=val0.begin();
21460  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> fixed_val0;
21461  unsigned int pad_count0=0;
21462  for(;it0!=val0.end();++it0){
21463  std::vector<std::pair<int, std::pair<std::string, std::string>>> child1val;
21464  unsigned int pad_count1val=0;
21465  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it1val=it0->second.begin();
21466  for(;it1val!=it0->second.end();++it1val){
21467  std::pair<int, std::pair<std::string, std::string>> child2valelem;
21468  unsigned int pad_count2valelem=0;
21469  std::pair<std::string, std::string> child3valelemsecond;
21470  unsigned int pad_count3valelemsecond=0;
21471  std::string child4valelemsecondsecond=std::string((*it1val).second.second,0,item_size4valelemsecondsecond);
21472  child3valelemsecond = std::make_pair((*it1val).second.first,child4valelemsecondsecond);
21473  child2valelem = std::make_pair((*it1val).first,child3valelemsecond);
21474  child1val.push_back(child2valelem);
21475  ++pad_count1val;
21476 
21477  }
21478  fixed_val0[it0->first] = child1val;
21479  ++pad_count0;
21480 
21481  }
21482  hasher_.Clear();
21483  hasher_.Update(fixed_val0);
21484  Digest key0 = hasher_.digest();
21485  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
21486  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
21487  if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
21488  hvl_t buf0 = VLValToBuf(fixed_val0);
21490  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
21491  }
21492  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21493 }
21494 template<>
21495 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21496  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> val0=a->cast<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>();
21497  size_t item_size0=(CYCLUS_SHA1_SIZE);
21498  size_t item_size1key=CYCLUS_SHA1_SIZE;
21499  size_t item_size1val=(CYCLUS_SHA1_SIZE);
21500  size_t item_size2valelem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
21501  size_t item_size3valelemfirst=sizeof(int);
21502  size_t item_size3valelemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
21503  size_t item_size4valelemsecondfirst=CYCLUS_SHA1_SIZE;
21504  size_t item_size4valelemsecondsecond=CYCLUS_SHA1_SIZE;
21505  size_t total_item_size3valelemsecond=item_size4valelemsecondfirst+item_size4valelemsecondsecond;
21506  size_t total_item_size2valelem=item_size3valelemfirst+item_size3valelemsecond;
21507  size_t total_item_size1val=item_size2valelem;
21508  size_t total_item_size0=item_size1key+item_size1val;
21509  hasher_.Clear();
21510  hasher_.Update(val0);
21511  Digest key0 = hasher_.digest();
21512  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
21513  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
21514  if (vlkeys_[VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
21515  hvl_t buf0 = VLValToBuf(val0);
21517  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
21518  }
21519  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21520 }
21521 template<>
21522 void Hdf5Back::WriteToBuf<LIST_PAIR_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21523  std::list<std::pair<int, int>> val0=a->cast<std::list<std::pair<int, int>>>();
21524  size_t item_size0=((((sizeof(int)+sizeof(int))))*shape[0]);
21525  size_t length0=shape[0];
21526  size_t item_size1elem=((sizeof(int)+sizeof(int)));
21527  size_t item_size2elemfirst=sizeof(int);
21528  size_t item_size2elemsecond=sizeof(int);
21529  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
21530  size_t total_item_size0=item_size1elem;
21531  if(total_item_size0*val0.size()>column){
21532  std::list<std::pair<int, int>>::iterator eraseit=val0.begin();
21533  std::advance(eraseit, column/total_item_size0);
21534  val0.erase(eraseit,val0.end());
21535 
21536  }
21537  unsigned int count0=0;
21538  std::list<std::pair<int, int>>::iterator it0=val0.begin();
21539  for(;it0!=val0.end();++it0){
21540  unsigned int count1elem=0;
21541  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
21542  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst, &(it0->second), item_size2elemsecond);
21543  ++count0;
21544 
21545  }
21546  if(total_item_size0*length0<column){
21547  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21548 
21549  }
21550 }
21551 template<>
21552 void Hdf5Back::WriteToBuf<VL_LIST_PAIR_INT_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21553  std::list<std::pair<int, int>> val0=a->cast<std::list<std::pair<int, int>>>();
21554  size_t item_size0=(CYCLUS_SHA1_SIZE);
21555  size_t item_size1elem=((sizeof(int)+sizeof(int)));
21556  size_t item_size2elemfirst=sizeof(int);
21557  size_t item_size2elemsecond=sizeof(int);
21558  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
21559  size_t total_item_size0=item_size1elem;
21560  hasher_.Clear();
21561  hasher_.Update(val0);
21562  Digest key0 = hasher_.digest();
21563  hid_t keysds0 = VLDataset(VL_LIST_PAIR_INT_INT, true);
21564  hid_t valsds0 = VLDataset(VL_LIST_PAIR_INT_INT, false);
21565  if (vlkeys_[VL_LIST_PAIR_INT_INT].count(key0) != 1) {
21566  hvl_t buf0 = VLValToBuf(val0);
21567  AppendVLKey(keysds0, VL_LIST_PAIR_INT_INT, key0);
21568  InsertVLVal(valsds0, VL_LIST_PAIR_INT_INT, key0, buf0);
21569  }
21570  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
21571 }
21572 template<>
21573 void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21574  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
21575  size_t item_size0=((shape[1]+((shape[3]+((sizeof(double))*shape[4]))))*shape[0]);
21576  size_t length0=shape[0];
21577  size_t item_size1key=shape[1];
21578  size_t valuelen1key;
21579  size_t item_size1val=((shape[3]+((sizeof(double))*shape[4])));
21580  size_t item_size2valfirst=shape[3];
21581  size_t valuelen2valfirst;
21582  size_t item_size2valsecond=((sizeof(double))*shape[4]);
21583  size_t length2valsecond=shape[4];
21584  size_t item_size3valsecondelem=sizeof(double);
21585  size_t total_item_size2valsecond=item_size3valsecondelem;
21586  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21587  size_t total_item_size0=item_size1key+item_size1val;
21588  if(total_item_size0*val0.size()>column){
21589  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21590  std::advance(eraseit, column/total_item_size0);
21591  val0.erase(eraseit,val0.end());
21592 
21593  }
21594  unsigned int count0=0;
21595  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21596  for(;it0!=val0.end();++it0){
21597  valuelen1key=std::min(it0->first.size(), item_size1key);
21598  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
21599  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
21600  unsigned int count1val=0;
21601  valuelen2valfirst=std::min(it0->second.first.size(), item_size2valfirst);
21602  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it0->second.first.c_str(), valuelen2valfirst);
21603  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valfirst, 0, item_size2valfirst-valuelen2valfirst);
21604  unsigned int count2valsecond=0;
21605  std::vector<double>::iterator it2valsecond=it0->second.second.begin();
21606  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
21607  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+item_size3valsecondelem*count2valsecond, &(*it2valsecond), item_size3valsecondelem);
21608  ++count2valsecond;
21609 
21610  }
21611  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+total_item_size2valsecond*count2valsecond, 0, total_item_size2valsecond*(length2valsecond-count2valsecond));
21612  ++count0;
21613 
21614  }
21615  if(total_item_size0*length0<column){
21616  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21617 
21618  }
21619 }
21620 template<>
21621 void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21622  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
21623  size_t item_size0=((shape[1]+((shape[3]+(CYCLUS_SHA1_SIZE))))*shape[0]);
21624  size_t length0=shape[0];
21625  size_t item_size1key=shape[1];
21626  size_t valuelen1key;
21627  size_t item_size1val=((shape[3]+(CYCLUS_SHA1_SIZE)));
21628  size_t item_size2valfirst=shape[3];
21629  size_t valuelen2valfirst;
21630  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
21631  size_t item_size3valsecondelem=sizeof(double);
21632  size_t total_item_size2valsecond=item_size3valsecondelem;
21633  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21634  size_t total_item_size0=item_size1key+item_size1val;
21635  if(total_item_size0*val0.size()>column){
21636  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21637  std::advance(eraseit, column/total_item_size0);
21638  val0.erase(eraseit,val0.end());
21639 
21640  }
21641  unsigned int count0=0;
21642  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21643  for(;it0!=val0.end();++it0){
21644  valuelen1key=std::min(it0->first.size(), item_size1key);
21645  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
21646  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
21647  unsigned int count1val=0;
21648  valuelen2valfirst=std::min(it0->second.first.size(), item_size2valfirst);
21649  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it0->second.first.c_str(), valuelen2valfirst);
21650  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valfirst, 0, item_size2valfirst-valuelen2valfirst);
21651  hasher_.Clear();
21652  hasher_.Update(it0->second.second);
21653  Digest key2valsecond = hasher_.digest();
21654  hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
21655  hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
21656  if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
21657  hvl_t buf2valsecond = VLValToBuf(it0->second.second);
21658  AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
21659  InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
21660  }
21661  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.val, CYCLUS_SHA1_SIZE);
21662  ++count0;
21663 
21664  }
21665  if(total_item_size0*length0<column){
21666  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21667 
21668  }
21669 }
21670 template<>
21671 void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21672  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
21673  size_t item_size0=((shape[1]+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))))*shape[0]);
21674  size_t length0=shape[0];
21675  size_t item_size1key=shape[1];
21676  size_t valuelen1key;
21677  size_t item_size1val=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4])));
21678  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
21679  size_t item_size2valsecond=((sizeof(double))*shape[4]);
21680  size_t length2valsecond=shape[4];
21681  size_t item_size3valsecondelem=sizeof(double);
21682  size_t total_item_size2valsecond=item_size3valsecondelem;
21683  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21684  size_t total_item_size0=item_size1key+item_size1val;
21685  if(total_item_size0*val0.size()>column){
21686  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21687  std::advance(eraseit, column/total_item_size0);
21688  val0.erase(eraseit,val0.end());
21689 
21690  }
21691  unsigned int count0=0;
21692  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21693  for(;it0!=val0.end();++it0){
21694  valuelen1key=std::min(it0->first.size(), item_size1key);
21695  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
21696  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
21697  unsigned int count1val=0;
21698  hasher_.Clear();
21699  hasher_.Update(it0->second.first);
21700  Digest key2valfirst = hasher_.digest();
21701  hid_t keysds2valfirst = VLDataset(VL_STRING, true);
21702  hid_t valsds2valfirst = VLDataset(VL_STRING, false);
21703  if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
21704  AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
21705  InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
21706  }
21707  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valfirst.val, CYCLUS_SHA1_SIZE);
21708  unsigned int count2valsecond=0;
21709  std::vector<double>::iterator it2valsecond=it0->second.second.begin();
21710  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
21711  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+item_size3valsecondelem*count2valsecond, &(*it2valsecond), item_size3valsecondelem);
21712  ++count2valsecond;
21713 
21714  }
21715  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+total_item_size2valsecond*count2valsecond, 0, total_item_size2valsecond*(length2valsecond-count2valsecond));
21716  ++count0;
21717 
21718  }
21719  if(total_item_size0*length0<column){
21720  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21721 
21722  }
21723 }
21724 template<>
21725 void Hdf5Back::WriteToBuf<MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21726  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
21727  size_t item_size0=((shape[1]+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))))*shape[0]);
21728  size_t length0=shape[0];
21729  size_t item_size1key=shape[1];
21730  size_t valuelen1key;
21731  size_t item_size1val=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
21732  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
21733  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
21734  size_t item_size3valsecondelem=sizeof(double);
21735  size_t total_item_size2valsecond=item_size3valsecondelem;
21736  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21737  size_t total_item_size0=item_size1key+item_size1val;
21738  if(total_item_size0*val0.size()>column){
21739  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21740  std::advance(eraseit, column/total_item_size0);
21741  val0.erase(eraseit,val0.end());
21742 
21743  }
21744  unsigned int count0=0;
21745  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21746  for(;it0!=val0.end();++it0){
21747  valuelen1key=std::min(it0->first.size(), item_size1key);
21748  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
21749  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
21750  unsigned int count1val=0;
21751  hasher_.Clear();
21752  hasher_.Update(it0->second.first);
21753  Digest key2valfirst = hasher_.digest();
21754  hid_t keysds2valfirst = VLDataset(VL_STRING, true);
21755  hid_t valsds2valfirst = VLDataset(VL_STRING, false);
21756  if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
21757  AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
21758  InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
21759  }
21760  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valfirst.val, CYCLUS_SHA1_SIZE);
21761  hasher_.Clear();
21762  hasher_.Update(it0->second.second);
21763  Digest key2valsecond = hasher_.digest();
21764  hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
21765  hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
21766  if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
21767  hvl_t buf2valsecond = VLValToBuf(it0->second.second);
21768  AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
21769  InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
21770  }
21771  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.val, CYCLUS_SHA1_SIZE);
21772  ++count0;
21773 
21774  }
21775  if(total_item_size0*length0<column){
21776  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21777 
21778  }
21779 }
21780 template<>
21781 void Hdf5Back::WriteToBuf<MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21782  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
21783  size_t item_size0=((CYCLUS_SHA1_SIZE+((shape[3]+((sizeof(double))*shape[4]))))*shape[0]);
21784  size_t length0=shape[0];
21785  size_t item_size1key=CYCLUS_SHA1_SIZE;
21786  size_t item_size1val=((shape[3]+((sizeof(double))*shape[4])));
21787  size_t item_size2valfirst=shape[3];
21788  size_t valuelen2valfirst;
21789  size_t item_size2valsecond=((sizeof(double))*shape[4]);
21790  size_t length2valsecond=shape[4];
21791  size_t item_size3valsecondelem=sizeof(double);
21792  size_t total_item_size2valsecond=item_size3valsecondelem;
21793  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21794  size_t total_item_size0=item_size1key+item_size1val;
21795  if(total_item_size0*val0.size()>column){
21796  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21797  std::advance(eraseit, column/total_item_size0);
21798  val0.erase(eraseit,val0.end());
21799 
21800  }
21801  unsigned int count0=0;
21802  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21803  for(;it0!=val0.end();++it0){
21804  hasher_.Clear();
21805  hasher_.Update(it0->first);
21806  Digest key1key = hasher_.digest();
21807  hid_t keysds1key = VLDataset(VL_STRING, true);
21808  hid_t valsds1key = VLDataset(VL_STRING, false);
21809  if (vlkeys_[VL_STRING].count(key1key) != 1) {
21810  AppendVLKey(keysds1key, VL_STRING, key1key);
21811  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
21812  }
21813  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
21814  unsigned int count1val=0;
21815  valuelen2valfirst=std::min(it0->second.first.size(), item_size2valfirst);
21816  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it0->second.first.c_str(), valuelen2valfirst);
21817  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valfirst, 0, item_size2valfirst-valuelen2valfirst);
21818  unsigned int count2valsecond=0;
21819  std::vector<double>::iterator it2valsecond=it0->second.second.begin();
21820  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
21821  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+item_size3valsecondelem*count2valsecond, &(*it2valsecond), item_size3valsecondelem);
21822  ++count2valsecond;
21823 
21824  }
21825  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+total_item_size2valsecond*count2valsecond, 0, total_item_size2valsecond*(length2valsecond-count2valsecond));
21826  ++count0;
21827 
21828  }
21829  if(total_item_size0*length0<column){
21830  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21831 
21832  }
21833 }
21834 template<>
21835 void Hdf5Back::WriteToBuf<MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21836  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
21837  size_t item_size0=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4]))))*shape[0]);
21838  size_t length0=shape[0];
21839  size_t item_size1key=CYCLUS_SHA1_SIZE;
21840  size_t item_size1val=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4])));
21841  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
21842  size_t item_size2valsecond=((sizeof(double))*shape[4]);
21843  size_t length2valsecond=shape[4];
21844  size_t item_size3valsecondelem=sizeof(double);
21845  size_t total_item_size2valsecond=item_size3valsecondelem;
21846  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21847  size_t total_item_size0=item_size1key+item_size1val;
21848  if(total_item_size0*val0.size()>column){
21849  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21850  std::advance(eraseit, column/total_item_size0);
21851  val0.erase(eraseit,val0.end());
21852 
21853  }
21854  unsigned int count0=0;
21855  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21856  for(;it0!=val0.end();++it0){
21857  hasher_.Clear();
21858  hasher_.Update(it0->first);
21859  Digest key1key = hasher_.digest();
21860  hid_t keysds1key = VLDataset(VL_STRING, true);
21861  hid_t valsds1key = VLDataset(VL_STRING, false);
21862  if (vlkeys_[VL_STRING].count(key1key) != 1) {
21863  AppendVLKey(keysds1key, VL_STRING, key1key);
21864  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
21865  }
21866  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
21867  unsigned int count1val=0;
21868  hasher_.Clear();
21869  hasher_.Update(it0->second.first);
21870  Digest key2valfirst = hasher_.digest();
21871  hid_t keysds2valfirst = VLDataset(VL_STRING, true);
21872  hid_t valsds2valfirst = VLDataset(VL_STRING, false);
21873  if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
21874  AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
21875  InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
21876  }
21877  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valfirst.val, CYCLUS_SHA1_SIZE);
21878  unsigned int count2valsecond=0;
21879  std::vector<double>::iterator it2valsecond=it0->second.second.begin();
21880  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
21881  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+item_size3valsecondelem*count2valsecond, &(*it2valsecond), item_size3valsecondelem);
21882  ++count2valsecond;
21883 
21884  }
21885  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst+total_item_size2valsecond*count2valsecond, 0, total_item_size2valsecond*(length2valsecond-count2valsecond));
21886  ++count0;
21887 
21888  }
21889  if(total_item_size0*length0<column){
21890  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21891 
21892  }
21893 }
21894 template<>
21895 void Hdf5Back::WriteToBuf<MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21896  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
21897  size_t item_size0=((CYCLUS_SHA1_SIZE+((shape[3]+(CYCLUS_SHA1_SIZE))))*shape[0]);
21898  size_t length0=shape[0];
21899  size_t item_size1key=CYCLUS_SHA1_SIZE;
21900  size_t item_size1val=((shape[3]+(CYCLUS_SHA1_SIZE)));
21901  size_t item_size2valfirst=shape[3];
21902  size_t valuelen2valfirst;
21903  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
21904  size_t item_size3valsecondelem=sizeof(double);
21905  size_t total_item_size2valsecond=item_size3valsecondelem;
21906  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21907  size_t total_item_size0=item_size1key+item_size1val;
21908  if(total_item_size0*val0.size()>column){
21909  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21910  std::advance(eraseit, column/total_item_size0);
21911  val0.erase(eraseit,val0.end());
21912 
21913  }
21914  unsigned int count0=0;
21915  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21916  for(;it0!=val0.end();++it0){
21917  hasher_.Clear();
21918  hasher_.Update(it0->first);
21919  Digest key1key = hasher_.digest();
21920  hid_t keysds1key = VLDataset(VL_STRING, true);
21921  hid_t valsds1key = VLDataset(VL_STRING, false);
21922  if (vlkeys_[VL_STRING].count(key1key) != 1) {
21923  AppendVLKey(keysds1key, VL_STRING, key1key);
21924  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
21925  }
21926  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
21927  unsigned int count1val=0;
21928  valuelen2valfirst=std::min(it0->second.first.size(), item_size2valfirst);
21929  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it0->second.first.c_str(), valuelen2valfirst);
21930  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valfirst, 0, item_size2valfirst-valuelen2valfirst);
21931  hasher_.Clear();
21932  hasher_.Update(it0->second.second);
21933  Digest key2valsecond = hasher_.digest();
21934  hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
21935  hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
21936  if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
21937  hvl_t buf2valsecond = VLValToBuf(it0->second.second);
21938  AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
21939  InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
21940  }
21941  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.val, CYCLUS_SHA1_SIZE);
21942  ++count0;
21943 
21944  }
21945  if(total_item_size0*length0<column){
21946  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
21947 
21948  }
21949 }
21950 template<>
21951 void Hdf5Back::WriteToBuf<MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
21952  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
21953  size_t item_size0=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))))*shape[0]);
21954  size_t length0=shape[0];
21955  size_t item_size1key=CYCLUS_SHA1_SIZE;
21956  size_t item_size1val=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
21957  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
21958  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
21959  size_t item_size3valsecondelem=sizeof(double);
21960  size_t total_item_size2valsecond=item_size3valsecondelem;
21961  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
21962  size_t total_item_size0=item_size1key+item_size1val;
21963  if(total_item_size0*val0.size()>column){
21964  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator eraseit=val0.begin();
21965  std::advance(eraseit, column/total_item_size0);
21966  val0.erase(eraseit,val0.end());
21967 
21968  }
21969  unsigned int count0=0;
21970  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
21971  for(;it0!=val0.end();++it0){
21972  hasher_.Clear();
21973  hasher_.Update(it0->first);
21974  Digest key1key = hasher_.digest();
21975  hid_t keysds1key = VLDataset(VL_STRING, true);
21976  hid_t valsds1key = VLDataset(VL_STRING, false);
21977  if (vlkeys_[VL_STRING].count(key1key) != 1) {
21978  AppendVLKey(keysds1key, VL_STRING, key1key);
21979  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
21980  }
21981  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
21982  unsigned int count1val=0;
21983  hasher_.Clear();
21984  hasher_.Update(it0->second.first);
21985  Digest key2valfirst = hasher_.digest();
21986  hid_t keysds2valfirst = VLDataset(VL_STRING, true);
21987  hid_t valsds2valfirst = VLDataset(VL_STRING, false);
21988  if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
21989  AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
21990  InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
21991  }
21992  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valfirst.val, CYCLUS_SHA1_SIZE);
21993  hasher_.Clear();
21994  hasher_.Update(it0->second.second);
21995  Digest key2valsecond = hasher_.digest();
21996  hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
21997  hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
21998  if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
21999  hvl_t buf2valsecond = VLValToBuf(it0->second.second);
22000  AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
22001  InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
22002  }
22003  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valfirst, key2valsecond.val, CYCLUS_SHA1_SIZE);
22004  ++count0;
22005 
22006  }
22007  if(total_item_size0*length0<column){
22008  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22009 
22010  }
22011 }
22012 template<>
22013 void Hdf5Back::WriteToBuf<VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22014  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
22015  size_t item_size0=(CYCLUS_SHA1_SIZE);
22016  size_t item_size1key=shape[1];
22017  size_t valuelen1key;
22018  size_t item_size1val=((shape[3]+((sizeof(double))*shape[4])));
22019  size_t item_size2valfirst=shape[3];
22020  size_t valuelen2valfirst;
22021  size_t item_size2valsecond=((sizeof(double))*shape[4]);
22022  size_t length2valsecond=shape[4];
22023  size_t item_size3valsecondelem=sizeof(double);
22024  size_t total_item_size2valsecond=item_size3valsecondelem;
22025  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22026  size_t total_item_size0=item_size1key+item_size1val;
22027  unsigned int count0=0;
22028  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22029  std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22030  unsigned int pad_count0=0;
22031  for(;it0!=val0.end();++it0){
22032  std::string child1key=std::string(it0->first,0,item_size1key);
22033  std::pair<std::string, std::vector<double>> child1val;
22034  unsigned int pad_count1val=0;
22035  std::string child2valfirst=std::string(it0->second.first,0,item_size2valfirst);
22036  std::vector<double> child2valsecond;
22037  unsigned int pad_count2valsecond=0;
22038  std::vector<double>::iterator it2valsecond=it0->second.second.begin();
22039  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
22040  child2valsecond.push_back((*it2valsecond));
22041  ++pad_count2valsecond;
22042 
22043  }
22044  child2valsecond.resize(length2valsecond);
22045  memset(&child2valsecond, 0, (length2valsecond-pad_count2valsecond)*item_size2valfirst);
22046  child1val = std::make_pair(child2valfirst,child2valsecond);
22047  fixed_val0[child1key] = child1val;
22048  ++pad_count0;
22049 
22050  }
22051  hasher_.Clear();
22052  hasher_.Update(fixed_val0);
22053  Digest key0 = hasher_.digest();
22054  hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE, true);
22055  hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE, false);
22056  if (vlkeys_[VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE].count(key0) != 1) {
22057  hvl_t buf0 = VLValToBuf(fixed_val0);
22058  AppendVLKey(keysds0, VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE, key0);
22059  InsertVLVal(valsds0, VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE, key0, buf0);
22060  }
22061  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22062 }
22063 template<>
22064 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22065  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
22066  size_t item_size0=(CYCLUS_SHA1_SIZE);
22067  size_t item_size1key=CYCLUS_SHA1_SIZE;
22068  size_t item_size1val=((shape[3]+((sizeof(double))*shape[4])));
22069  size_t item_size2valfirst=shape[3];
22070  size_t valuelen2valfirst;
22071  size_t item_size2valsecond=((sizeof(double))*shape[4]);
22072  size_t length2valsecond=shape[4];
22073  size_t item_size3valsecondelem=sizeof(double);
22074  size_t total_item_size2valsecond=item_size3valsecondelem;
22075  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22076  size_t total_item_size0=item_size1key+item_size1val;
22077  unsigned int count0=0;
22078  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22079  std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22080  unsigned int pad_count0=0;
22081  for(;it0!=val0.end();++it0){
22082  std::pair<std::string, std::vector<double>> child1val;
22083  unsigned int pad_count1val=0;
22084  std::string child2valfirst=std::string(it0->second.first,0,item_size2valfirst);
22085  std::vector<double> child2valsecond;
22086  unsigned int pad_count2valsecond=0;
22087  std::vector<double>::iterator it2valsecond=it0->second.second.begin();
22088  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
22089  child2valsecond.push_back((*it2valsecond));
22090  ++pad_count2valsecond;
22091 
22092  }
22093  child2valsecond.resize(length2valsecond);
22094  memset(&child2valsecond, 0, (length2valsecond-pad_count2valsecond)*item_size2valfirst);
22095  child1val = std::make_pair(child2valfirst,child2valsecond);
22096  fixed_val0[it0->first] = child1val;
22097  ++pad_count0;
22098 
22099  }
22100  hasher_.Clear();
22101  hasher_.Update(fixed_val0);
22102  Digest key0 = hasher_.digest();
22103  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE, true);
22104  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE, false);
22105  if (vlkeys_[VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE].count(key0) != 1) {
22106  hvl_t buf0 = VLValToBuf(fixed_val0);
22107  AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE, key0);
22108  InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE, key0, buf0);
22109  }
22110  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22111 }
22112 template<>
22113 void Hdf5Back::WriteToBuf<VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22114  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
22115  size_t item_size0=(CYCLUS_SHA1_SIZE);
22116  size_t item_size1key=shape[1];
22117  size_t valuelen1key;
22118  size_t item_size1val=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4])));
22119  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
22120  size_t item_size2valsecond=((sizeof(double))*shape[4]);
22121  size_t length2valsecond=shape[4];
22122  size_t item_size3valsecondelem=sizeof(double);
22123  size_t total_item_size2valsecond=item_size3valsecondelem;
22124  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22125  size_t total_item_size0=item_size1key+item_size1val;
22126  unsigned int count0=0;
22127  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22128  std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22129  unsigned int pad_count0=0;
22130  for(;it0!=val0.end();++it0){
22131  std::string child1key=std::string(it0->first,0,item_size1key);
22132  std::pair<std::string, std::vector<double>> child1val;
22133  unsigned int pad_count1val=0;
22134  std::vector<double> child2valsecond;
22135  unsigned int pad_count2valsecond=0;
22136  std::vector<double>::iterator it2valsecond=it0->second.second.begin();
22137  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
22138  child2valsecond.push_back((*it2valsecond));
22139  ++pad_count2valsecond;
22140 
22141  }
22142  child2valsecond.resize(length2valsecond);
22143  memset(&child2valsecond, 0, (length2valsecond-pad_count2valsecond)*item_size2valfirst);
22144  child1val = std::make_pair(it0->second.first,child2valsecond);
22145  fixed_val0[child1key] = child1val;
22146  ++pad_count0;
22147 
22148  }
22149  hasher_.Clear();
22150  hasher_.Update(fixed_val0);
22151  Digest key0 = hasher_.digest();
22152  hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, true);
22153  hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, false);
22154  if (vlkeys_[VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE].count(key0) != 1) {
22155  hvl_t buf0 = VLValToBuf(fixed_val0);
22156  AppendVLKey(keysds0, VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, key0);
22157  InsertVLVal(valsds0, VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, key0, buf0);
22158  }
22159  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22160 }
22161 template<>
22162 void Hdf5Back::WriteToBuf<VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22163  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
22164  size_t item_size0=(CYCLUS_SHA1_SIZE);
22165  size_t item_size1key=shape[1];
22166  size_t valuelen1key;
22167  size_t item_size1val=((shape[3]+(CYCLUS_SHA1_SIZE)));
22168  size_t item_size2valfirst=shape[3];
22169  size_t valuelen2valfirst;
22170  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
22171  size_t item_size3valsecondelem=sizeof(double);
22172  size_t total_item_size2valsecond=item_size3valsecondelem;
22173  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22174  size_t total_item_size0=item_size1key+item_size1val;
22175  unsigned int count0=0;
22176  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22177  std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22178  unsigned int pad_count0=0;
22179  for(;it0!=val0.end();++it0){
22180  std::string child1key=std::string(it0->first,0,item_size1key);
22181  std::pair<std::string, std::vector<double>> child1val;
22182  unsigned int pad_count1val=0;
22183  std::string child2valfirst=std::string(it0->second.first,0,item_size2valfirst);
22184  child1val = std::make_pair(child2valfirst,it0->second.second);
22185  fixed_val0[child1key] = child1val;
22186  ++pad_count0;
22187 
22188  }
22189  hasher_.Clear();
22190  hasher_.Update(fixed_val0);
22191  Digest key0 = hasher_.digest();
22192  hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, true);
22193  hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, false);
22194  if (vlkeys_[VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
22195  hvl_t buf0 = VLValToBuf(fixed_val0);
22196  AppendVLKey(keysds0, VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, key0);
22197  InsertVLVal(valsds0, VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, key0, buf0);
22198  }
22199  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22200 }
22201 template<>
22202 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22203  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
22204  size_t item_size0=(CYCLUS_SHA1_SIZE);
22205  size_t item_size1key=CYCLUS_SHA1_SIZE;
22206  size_t item_size1val=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[4])));
22207  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
22208  size_t item_size2valsecond=((sizeof(double))*shape[4]);
22209  size_t length2valsecond=shape[4];
22210  size_t item_size3valsecondelem=sizeof(double);
22211  size_t total_item_size2valsecond=item_size3valsecondelem;
22212  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22213  size_t total_item_size0=item_size1key+item_size1val;
22214  unsigned int count0=0;
22215  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22216  std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22217  unsigned int pad_count0=0;
22218  for(;it0!=val0.end();++it0){
22219  std::pair<std::string, std::vector<double>> child1val;
22220  unsigned int pad_count1val=0;
22221  std::vector<double> child2valsecond;
22222  unsigned int pad_count2valsecond=0;
22223  std::vector<double>::iterator it2valsecond=it0->second.second.begin();
22224  for(;it2valsecond!=it0->second.second.end();++it2valsecond){
22225  child2valsecond.push_back((*it2valsecond));
22226  ++pad_count2valsecond;
22227 
22228  }
22229  child2valsecond.resize(length2valsecond);
22230  memset(&child2valsecond, 0, (length2valsecond-pad_count2valsecond)*item_size2valfirst);
22231  child1val = std::make_pair(it0->second.first,child2valsecond);
22232  fixed_val0[it0->first] = child1val;
22233  ++pad_count0;
22234 
22235  }
22236  hasher_.Clear();
22237  hasher_.Update(fixed_val0);
22238  Digest key0 = hasher_.digest();
22239  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, true);
22240  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, false);
22241  if (vlkeys_[VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE].count(key0) != 1) {
22242  hvl_t buf0 = VLValToBuf(fixed_val0);
22243  AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, key0);
22244  InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE, key0, buf0);
22245  }
22246  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22247 }
22248 template<>
22249 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22250  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
22251  size_t item_size0=(CYCLUS_SHA1_SIZE);
22252  size_t item_size1key=CYCLUS_SHA1_SIZE;
22253  size_t item_size1val=((shape[3]+(CYCLUS_SHA1_SIZE)));
22254  size_t item_size2valfirst=shape[3];
22255  size_t valuelen2valfirst;
22256  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
22257  size_t item_size3valsecondelem=sizeof(double);
22258  size_t total_item_size2valsecond=item_size3valsecondelem;
22259  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22260  size_t total_item_size0=item_size1key+item_size1val;
22261  unsigned int count0=0;
22262  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22263  std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22264  unsigned int pad_count0=0;
22265  for(;it0!=val0.end();++it0){
22266  std::pair<std::string, std::vector<double>> child1val;
22267  unsigned int pad_count1val=0;
22268  std::string child2valfirst=std::string(it0->second.first,0,item_size2valfirst);
22269  child1val = std::make_pair(child2valfirst,it0->second.second);
22270  fixed_val0[it0->first] = child1val;
22271  ++pad_count0;
22272 
22273  }
22274  hasher_.Clear();
22275  hasher_.Update(fixed_val0);
22276  Digest key0 = hasher_.digest();
22277  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, true);
22278  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, false);
22279  if (vlkeys_[VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
22280  hvl_t buf0 = VLValToBuf(fixed_val0);
22281  AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, key0);
22282  InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE, key0, buf0);
22283  }
22284  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22285 }
22286 template<>
22287 void Hdf5Back::WriteToBuf<VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22288  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
22289  size_t item_size0=(CYCLUS_SHA1_SIZE);
22290  size_t item_size1key=shape[1];
22291  size_t valuelen1key;
22292  size_t item_size1val=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
22293  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
22294  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
22295  size_t item_size3valsecondelem=sizeof(double);
22296  size_t total_item_size2valsecond=item_size3valsecondelem;
22297  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22298  size_t total_item_size0=item_size1key+item_size1val;
22299  unsigned int count0=0;
22300  std::map<std::string, std::pair<std::string, std::vector<double>>>::iterator it0=val0.begin();
22301  std::map<std::string, std::pair<std::string, std::vector<double>>> fixed_val0;
22302  unsigned int pad_count0=0;
22303  for(;it0!=val0.end();++it0){
22304  std::string child1key=std::string(it0->first,0,item_size1key);
22305  std::pair<std::string, std::vector<double>> child1val;
22306  unsigned int pad_count1val=0;
22307  child1val = std::make_pair(it0->second.first,it0->second.second);
22308  fixed_val0[child1key] = child1val;
22309  ++pad_count0;
22310 
22311  }
22312  hasher_.Clear();
22313  hasher_.Update(fixed_val0);
22314  Digest key0 = hasher_.digest();
22315  hid_t keysds0 = VLDataset(VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, true);
22316  hid_t valsds0 = VLDataset(VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, false);
22317  if (vlkeys_[VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
22318  hvl_t buf0 = VLValToBuf(fixed_val0);
22319  AppendVLKey(keysds0, VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, key0);
22320  InsertVLVal(valsds0, VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, key0, buf0);
22321  }
22322  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22323 }
22324 template<>
22325 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22326  std::map<std::string, std::pair<std::string, std::vector<double>>> val0=a->cast<std::map<std::string, std::pair<std::string, std::vector<double>>>>();
22327  size_t item_size0=(CYCLUS_SHA1_SIZE);
22328  size_t item_size1key=CYCLUS_SHA1_SIZE;
22329  size_t item_size1val=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
22330  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
22331  size_t item_size2valsecond=(CYCLUS_SHA1_SIZE);
22332  size_t item_size3valsecondelem=sizeof(double);
22333  size_t total_item_size2valsecond=item_size3valsecondelem;
22334  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
22335  size_t total_item_size0=item_size1key+item_size1val;
22336  hasher_.Clear();
22337  hasher_.Update(val0);
22338  Digest key0 = hasher_.digest();
22339  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, true);
22340  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, false);
22341  if (vlkeys_[VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE].count(key0) != 1) {
22342  hvl_t buf0 = VLValToBuf(val0);
22343  AppendVLKey(keysds0, VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, key0);
22344  InsertVLVal(valsds0, VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE, key0, buf0);
22345  }
22346  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22347 }
22348 template<>
22349 void Hdf5Back::WriteToBuf<MAP_STRING_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22350  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22351  size_t item_size0=((shape[1]+((shape[3]+sizeof(int))*shape[2]))*shape[0]);
22352  size_t length0=shape[0];
22353  size_t item_size1key=shape[1];
22354  size_t valuelen1key;
22355  size_t item_size1val=((shape[3]+sizeof(int))*shape[2]);
22356  size_t length1val=shape[2];
22357  size_t item_size2valkey=shape[3];
22358  size_t valuelen2valkey;
22359  size_t item_size2valval=sizeof(int);
22360  size_t total_item_size1val=item_size2valkey+item_size2valval;
22361  size_t total_item_size0=item_size1key+item_size1val;
22362  if(total_item_size0*val0.size()>column){
22363  std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22364  std::advance(eraseit, column/total_item_size0);
22365  val0.erase(eraseit,val0.end());
22366 
22367  }
22368  unsigned int count0=0;
22369  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22370  for(;it0!=val0.end();++it0){
22371  valuelen1key=std::min(it0->first.size(), item_size1key);
22372  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
22373  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
22374  unsigned int count1val=0;
22375  std::map<std::string, int>::iterator it1val=it0->second.begin();
22376  for(;it1val!=it0->second.end();++it1val){
22377  valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
22378  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
22379  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
22380  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
22381  ++count1val;
22382 
22383  }
22384  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
22385  ++count0;
22386 
22387  }
22388  if(total_item_size0*length0<column){
22389  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22390 
22391  }
22392 }
22393 template<>
22394 void Hdf5Back::WriteToBuf<MAP_STRING_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22395  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22396  size_t item_size0=((shape[1]+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]))*shape[0]);
22397  size_t length0=shape[0];
22398  size_t item_size1key=shape[1];
22399  size_t valuelen1key;
22400  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]);
22401  size_t length1val=shape[2];
22402  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22403  size_t item_size2valval=sizeof(int);
22404  size_t total_item_size1val=item_size2valkey+item_size2valval;
22405  size_t total_item_size0=item_size1key+item_size1val;
22406  if(total_item_size0*val0.size()>column){
22407  std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22408  std::advance(eraseit, column/total_item_size0);
22409  val0.erase(eraseit,val0.end());
22410 
22411  }
22412  unsigned int count0=0;
22413  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22414  for(;it0!=val0.end();++it0){
22415  valuelen1key=std::min(it0->first.size(), item_size1key);
22416  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
22417  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
22418  unsigned int count1val=0;
22419  std::map<std::string, int>::iterator it1val=it0->second.begin();
22420  for(;it1val!=it0->second.end();++it1val){
22421  hasher_.Clear();
22422  hasher_.Update(it1val->first);
22423  Digest key2valkey = hasher_.digest();
22424  hid_t keysds2valkey = VLDataset(VL_STRING, true);
22425  hid_t valsds2valkey = VLDataset(VL_STRING, false);
22426  if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
22427  AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
22428  InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
22429  }
22430  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.val, CYCLUS_SHA1_SIZE);
22431  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
22432  ++count1val;
22433 
22434  }
22435  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
22436  ++count0;
22437 
22438  }
22439  if(total_item_size0*length0<column){
22440  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22441 
22442  }
22443 }
22444 template<>
22445 void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22446  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22447  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
22448  size_t length0=shape[0];
22449  size_t item_size1key=shape[1];
22450  size_t valuelen1key;
22451  size_t item_size1val=(CYCLUS_SHA1_SIZE);
22452  size_t item_size2valkey=shape[3];
22453  size_t valuelen2valkey;
22454  size_t item_size2valval=sizeof(int);
22455  size_t total_item_size1val=item_size2valkey+item_size2valval;
22456  size_t total_item_size0=item_size1key+item_size1val;
22457  if(total_item_size0*val0.size()>column){
22458  std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22459  std::advance(eraseit, column/total_item_size0);
22460  val0.erase(eraseit,val0.end());
22461 
22462  }
22463  unsigned int count0=0;
22464  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22465  for(;it0!=val0.end();++it0){
22466  valuelen1key=std::min(it0->first.size(), item_size1key);
22467  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
22468  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
22469  unsigned int count1val=0;
22470  std::map<std::string, int>::iterator it1val=it0->second.begin();
22471  std::map<std::string, int> fixed_val1val;
22472  unsigned int pad_count1val=0;
22473  for(;it1val!=it0->second.end();++it1val){
22474  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22475  fixed_val1val[child2valkey] = it1val->second;
22476  ++pad_count1val;
22477 
22478  }
22479  hasher_.Clear();
22480  hasher_.Update(fixed_val1val);
22481  Digest key1val = hasher_.digest();
22482  hid_t keysds1val = VLDataset(VL_MAP_STRING_INT, true);
22483  hid_t valsds1val = VLDataset(VL_MAP_STRING_INT, false);
22484  if (vlkeys_[VL_MAP_STRING_INT].count(key1val) != 1) {
22485  hvl_t buf1val = VLValToBuf(fixed_val1val);
22486  AppendVLKey(keysds1val, VL_MAP_STRING_INT, key1val);
22487  InsertVLVal(valsds1val, VL_MAP_STRING_INT, key1val, buf1val);
22488  }
22489  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
22490  ++count0;
22491 
22492  }
22493  if(total_item_size0*length0<column){
22494  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22495 
22496  }
22497 }
22498 template<>
22499 void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22500  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22501  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
22502  size_t length0=shape[0];
22503  size_t item_size1key=shape[1];
22504  size_t valuelen1key;
22505  size_t item_size1val=(CYCLUS_SHA1_SIZE);
22506  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22507  size_t item_size2valval=sizeof(int);
22508  size_t total_item_size1val=item_size2valkey+item_size2valval;
22509  size_t total_item_size0=item_size1key+item_size1val;
22510  if(total_item_size0*val0.size()>column){
22511  std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22512  std::advance(eraseit, column/total_item_size0);
22513  val0.erase(eraseit,val0.end());
22514 
22515  }
22516  unsigned int count0=0;
22517  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22518  for(;it0!=val0.end();++it0){
22519  valuelen1key=std::min(it0->first.size(), item_size1key);
22520  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
22521  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
22522  hasher_.Clear();
22523  hasher_.Update(it0->second);
22524  Digest key1val = hasher_.digest();
22525  hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_INT, true);
22526  hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_INT, false);
22527  if (vlkeys_[VL_MAP_VL_STRING_INT].count(key1val) != 1) {
22528  hvl_t buf1val = VLValToBuf(it0->second);
22529  AppendVLKey(keysds1val, VL_MAP_VL_STRING_INT, key1val);
22530  InsertVLVal(valsds1val, VL_MAP_VL_STRING_INT, key1val, buf1val);
22531  }
22532  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
22533  ++count0;
22534 
22535  }
22536  if(total_item_size0*length0<column){
22537  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22538 
22539  }
22540 }
22541 template<>
22542 void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22543  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22544  size_t item_size0=((CYCLUS_SHA1_SIZE+((shape[3]+sizeof(int))*shape[2]))*shape[0]);
22545  size_t length0=shape[0];
22546  size_t item_size1key=CYCLUS_SHA1_SIZE;
22547  size_t item_size1val=((shape[3]+sizeof(int))*shape[2]);
22548  size_t length1val=shape[2];
22549  size_t item_size2valkey=shape[3];
22550  size_t valuelen2valkey;
22551  size_t item_size2valval=sizeof(int);
22552  size_t total_item_size1val=item_size2valkey+item_size2valval;
22553  size_t total_item_size0=item_size1key+item_size1val;
22554  if(total_item_size0*val0.size()>column){
22555  std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22556  std::advance(eraseit, column/total_item_size0);
22557  val0.erase(eraseit,val0.end());
22558 
22559  }
22560  unsigned int count0=0;
22561  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22562  for(;it0!=val0.end();++it0){
22563  hasher_.Clear();
22564  hasher_.Update(it0->first);
22565  Digest key1key = hasher_.digest();
22566  hid_t keysds1key = VLDataset(VL_STRING, true);
22567  hid_t valsds1key = VLDataset(VL_STRING, false);
22568  if (vlkeys_[VL_STRING].count(key1key) != 1) {
22569  AppendVLKey(keysds1key, VL_STRING, key1key);
22570  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
22571  }
22572  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
22573  unsigned int count1val=0;
22574  std::map<std::string, int>::iterator it1val=it0->second.begin();
22575  for(;it1val!=it0->second.end();++it1val){
22576  valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
22577  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
22578  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
22579  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
22580  ++count1val;
22581 
22582  }
22583  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
22584  ++count0;
22585 
22586  }
22587  if(total_item_size0*length0<column){
22588  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22589 
22590  }
22591 }
22592 template<>
22593 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22594  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22595  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
22596  size_t length0=shape[0];
22597  size_t item_size1key=CYCLUS_SHA1_SIZE;
22598  size_t item_size1val=(CYCLUS_SHA1_SIZE);
22599  size_t item_size2valkey=shape[3];
22600  size_t valuelen2valkey;
22601  size_t item_size2valval=sizeof(int);
22602  size_t total_item_size1val=item_size2valkey+item_size2valval;
22603  size_t total_item_size0=item_size1key+item_size1val;
22604  if(total_item_size0*val0.size()>column){
22605  std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22606  std::advance(eraseit, column/total_item_size0);
22607  val0.erase(eraseit,val0.end());
22608 
22609  }
22610  unsigned int count0=0;
22611  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22612  for(;it0!=val0.end();++it0){
22613  hasher_.Clear();
22614  hasher_.Update(it0->first);
22615  Digest key1key = hasher_.digest();
22616  hid_t keysds1key = VLDataset(VL_STRING, true);
22617  hid_t valsds1key = VLDataset(VL_STRING, false);
22618  if (vlkeys_[VL_STRING].count(key1key) != 1) {
22619  AppendVLKey(keysds1key, VL_STRING, key1key);
22620  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
22621  }
22622  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
22623  unsigned int count1val=0;
22624  std::map<std::string, int>::iterator it1val=it0->second.begin();
22625  std::map<std::string, int> fixed_val1val;
22626  unsigned int pad_count1val=0;
22627  for(;it1val!=it0->second.end();++it1val){
22628  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22629  fixed_val1val[child2valkey] = it1val->second;
22630  ++pad_count1val;
22631 
22632  }
22633  hasher_.Clear();
22634  hasher_.Update(fixed_val1val);
22635  Digest key1val = hasher_.digest();
22636  hid_t keysds1val = VLDataset(VL_MAP_STRING_INT, true);
22637  hid_t valsds1val = VLDataset(VL_MAP_STRING_INT, false);
22638  if (vlkeys_[VL_MAP_STRING_INT].count(key1val) != 1) {
22639  hvl_t buf1val = VLValToBuf(fixed_val1val);
22640  AppendVLKey(keysds1val, VL_MAP_STRING_INT, key1val);
22641  InsertVLVal(valsds1val, VL_MAP_STRING_INT, key1val, buf1val);
22642  }
22643  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
22644  ++count0;
22645 
22646  }
22647  if(total_item_size0*length0<column){
22648  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22649 
22650  }
22651 }
22652 template<>
22653 void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22654  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22655  size_t item_size0=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]))*shape[0]);
22656  size_t length0=shape[0];
22657  size_t item_size1key=CYCLUS_SHA1_SIZE;
22658  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]);
22659  size_t length1val=shape[2];
22660  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22661  size_t item_size2valval=sizeof(int);
22662  size_t total_item_size1val=item_size2valkey+item_size2valval;
22663  size_t total_item_size0=item_size1key+item_size1val;
22664  if(total_item_size0*val0.size()>column){
22665  std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22666  std::advance(eraseit, column/total_item_size0);
22667  val0.erase(eraseit,val0.end());
22668 
22669  }
22670  unsigned int count0=0;
22671  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22672  for(;it0!=val0.end();++it0){
22673  hasher_.Clear();
22674  hasher_.Update(it0->first);
22675  Digest key1key = hasher_.digest();
22676  hid_t keysds1key = VLDataset(VL_STRING, true);
22677  hid_t valsds1key = VLDataset(VL_STRING, false);
22678  if (vlkeys_[VL_STRING].count(key1key) != 1) {
22679  AppendVLKey(keysds1key, VL_STRING, key1key);
22680  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
22681  }
22682  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
22683  unsigned int count1val=0;
22684  std::map<std::string, int>::iterator it1val=it0->second.begin();
22685  for(;it1val!=it0->second.end();++it1val){
22686  hasher_.Clear();
22687  hasher_.Update(it1val->first);
22688  Digest key2valkey = hasher_.digest();
22689  hid_t keysds2valkey = VLDataset(VL_STRING, true);
22690  hid_t valsds2valkey = VLDataset(VL_STRING, false);
22691  if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
22692  AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
22693  InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
22694  }
22695  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.val, CYCLUS_SHA1_SIZE);
22696  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
22697  ++count1val;
22698 
22699  }
22700  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
22701  ++count0;
22702 
22703  }
22704  if(total_item_size0*length0<column){
22705  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22706 
22707  }
22708 }
22709 template<>
22710 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22711  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22712  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
22713  size_t length0=shape[0];
22714  size_t item_size1key=CYCLUS_SHA1_SIZE;
22715  size_t item_size1val=(CYCLUS_SHA1_SIZE);
22716  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22717  size_t item_size2valval=sizeof(int);
22718  size_t total_item_size1val=item_size2valkey+item_size2valval;
22719  size_t total_item_size0=item_size1key+item_size1val;
22720  if(total_item_size0*val0.size()>column){
22721  std::map<std::string, std::map<std::string, int>>::iterator eraseit=val0.begin();
22722  std::advance(eraseit, column/total_item_size0);
22723  val0.erase(eraseit,val0.end());
22724 
22725  }
22726  unsigned int count0=0;
22727  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22728  for(;it0!=val0.end();++it0){
22729  hasher_.Clear();
22730  hasher_.Update(it0->first);
22731  Digest key1key = hasher_.digest();
22732  hid_t keysds1key = VLDataset(VL_STRING, true);
22733  hid_t valsds1key = VLDataset(VL_STRING, false);
22734  if (vlkeys_[VL_STRING].count(key1key) != 1) {
22735  AppendVLKey(keysds1key, VL_STRING, key1key);
22736  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
22737  }
22738  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
22739  hasher_.Clear();
22740  hasher_.Update(it0->second);
22741  Digest key1val = hasher_.digest();
22742  hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_INT, true);
22743  hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_INT, false);
22744  if (vlkeys_[VL_MAP_VL_STRING_INT].count(key1val) != 1) {
22745  hvl_t buf1val = VLValToBuf(it0->second);
22746  AppendVLKey(keysds1val, VL_MAP_VL_STRING_INT, key1val);
22747  InsertVLVal(valsds1val, VL_MAP_VL_STRING_INT, key1val, buf1val);
22748  }
22749  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
22750  ++count0;
22751 
22752  }
22753  if(total_item_size0*length0<column){
22754  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
22755 
22756  }
22757 }
22758 template<>
22759 void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22760  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22761  size_t item_size0=(CYCLUS_SHA1_SIZE);
22762  size_t item_size1key=shape[1];
22763  size_t valuelen1key;
22764  size_t item_size1val=((shape[3]+sizeof(int))*shape[2]);
22765  size_t length1val=shape[2];
22766  size_t item_size2valkey=shape[3];
22767  size_t valuelen2valkey;
22768  size_t item_size2valval=sizeof(int);
22769  size_t total_item_size1val=item_size2valkey+item_size2valval;
22770  size_t total_item_size0=item_size1key+item_size1val;
22771  unsigned int count0=0;
22772  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22773  std::map<std::string, std::map<std::string, int>> fixed_val0;
22774  unsigned int pad_count0=0;
22775  for(;it0!=val0.end();++it0){
22776  std::string child1key=std::string(it0->first,0,item_size1key);
22777  std::map<std::string, int> child1val;
22778  unsigned int pad_count1val=0;
22779  std::map<std::string, int>::iterator it1val=it0->second.begin();
22780  for(;it1val!=it0->second.end();++it1val){
22781  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22782  child1val[child2valkey] = it1val->second;
22783  ++pad_count1val;
22784 
22785  }
22786  fixed_val0[child1key] = child1val;
22787  ++pad_count0;
22788 
22789  }
22790  hasher_.Clear();
22791  hasher_.Update(fixed_val0);
22792  Digest key0 = hasher_.digest();
22793  hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_STRING_INT, true);
22794  hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_STRING_INT, false);
22795  if (vlkeys_[VL_MAP_STRING_MAP_STRING_INT].count(key0) != 1) {
22796  hvl_t buf0 = VLValToBuf(fixed_val0);
22797  AppendVLKey(keysds0, VL_MAP_STRING_MAP_STRING_INT, key0);
22798  InsertVLVal(valsds0, VL_MAP_STRING_MAP_STRING_INT, key0, buf0);
22799  }
22800  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22801 }
22802 template<>
22803 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22804  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22805  size_t item_size0=(CYCLUS_SHA1_SIZE);
22806  size_t item_size1key=CYCLUS_SHA1_SIZE;
22807  size_t item_size1val=((shape[3]+sizeof(int))*shape[2]);
22808  size_t length1val=shape[2];
22809  size_t item_size2valkey=shape[3];
22810  size_t valuelen2valkey;
22811  size_t item_size2valval=sizeof(int);
22812  size_t total_item_size1val=item_size2valkey+item_size2valval;
22813  size_t total_item_size0=item_size1key+item_size1val;
22814  unsigned int count0=0;
22815  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22816  std::map<std::string, std::map<std::string, int>> fixed_val0;
22817  unsigned int pad_count0=0;
22818  for(;it0!=val0.end();++it0){
22819  std::map<std::string, int> child1val;
22820  unsigned int pad_count1val=0;
22821  std::map<std::string, int>::iterator it1val=it0->second.begin();
22822  for(;it1val!=it0->second.end();++it1val){
22823  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22824  child1val[child2valkey] = it1val->second;
22825  ++pad_count1val;
22826 
22827  }
22828  fixed_val0[it0->first] = child1val;
22829  ++pad_count0;
22830 
22831  }
22832  hasher_.Clear();
22833  hasher_.Update(fixed_val0);
22834  Digest key0 = hasher_.digest();
22835  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_STRING_INT, true);
22836  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_STRING_INT, false);
22837  if (vlkeys_[VL_MAP_VL_STRING_MAP_STRING_INT].count(key0) != 1) {
22838  hvl_t buf0 = VLValToBuf(fixed_val0);
22839  AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_STRING_INT, key0);
22840  InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_STRING_INT, key0, buf0);
22841  }
22842  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22843 }
22844 template<>
22845 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22846  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22847  size_t item_size0=(CYCLUS_SHA1_SIZE);
22848  size_t item_size1key=shape[1];
22849  size_t valuelen1key;
22850  size_t item_size1val=(CYCLUS_SHA1_SIZE);
22851  size_t item_size2valkey=shape[3];
22852  size_t valuelen2valkey;
22853  size_t item_size2valval=sizeof(int);
22854  size_t total_item_size1val=item_size2valkey+item_size2valval;
22855  size_t total_item_size0=item_size1key+item_size1val;
22856  unsigned int count0=0;
22857  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22858  std::map<std::string, std::map<std::string, int>> fixed_val0;
22859  unsigned int pad_count0=0;
22860  for(;it0!=val0.end();++it0){
22861  std::string child1key=std::string(it0->first,0,item_size1key);
22862  std::map<std::string, int> child1val;
22863  unsigned int pad_count1val=0;
22864  std::map<std::string, int>::iterator it1val=it0->second.begin();
22865  for(;it1val!=it0->second.end();++it1val){
22866  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
22867  child1val[child2valkey] = it1val->second;
22868  ++pad_count1val;
22869 
22870  }
22871  fixed_val0[child1key] = child1val;
22872  ++pad_count0;
22873 
22874  }
22875  hasher_.Clear();
22876  hasher_.Update(fixed_val0);
22877  Digest key0 = hasher_.digest();
22878  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_STRING_INT, true);
22879  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_STRING_INT, false);
22880  if (vlkeys_[VL_MAP_STRING_VL_MAP_STRING_INT].count(key0) != 1) {
22881  hvl_t buf0 = VLValToBuf(fixed_val0);
22882  AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_STRING_INT, key0);
22883  InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_STRING_INT, key0, buf0);
22884  }
22885  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22886 }
22887 template<>
22888 void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22889  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22890  size_t item_size0=(CYCLUS_SHA1_SIZE);
22891  size_t item_size1key=shape[1];
22892  size_t valuelen1key;
22893  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]);
22894  size_t length1val=shape[2];
22895  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22896  size_t item_size2valval=sizeof(int);
22897  size_t total_item_size1val=item_size2valkey+item_size2valval;
22898  size_t total_item_size0=item_size1key+item_size1val;
22899  unsigned int count0=0;
22900  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22901  std::map<std::string, std::map<std::string, int>> fixed_val0;
22902  unsigned int pad_count0=0;
22903  for(;it0!=val0.end();++it0){
22904  std::string child1key=std::string(it0->first,0,item_size1key);
22905  std::map<std::string, int> child1val;
22906  unsigned int pad_count1val=0;
22907  std::map<std::string, int>::iterator it1val=it0->second.begin();
22908  for(;it1val!=it0->second.end();++it1val){
22909  child1val[it1val->first] = it1val->second;
22910  ++pad_count1val;
22911 
22912  }
22913  fixed_val0[child1key] = child1val;
22914  ++pad_count0;
22915 
22916  }
22917  hasher_.Clear();
22918  hasher_.Update(fixed_val0);
22919  Digest key0 = hasher_.digest();
22920  hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_VL_STRING_INT, true);
22921  hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_VL_STRING_INT, false);
22922  if (vlkeys_[VL_MAP_STRING_MAP_VL_STRING_INT].count(key0) != 1) {
22923  hvl_t buf0 = VLValToBuf(fixed_val0);
22924  AppendVLKey(keysds0, VL_MAP_STRING_MAP_VL_STRING_INT, key0);
22925  InsertVLVal(valsds0, VL_MAP_STRING_MAP_VL_STRING_INT, key0, buf0);
22926  }
22927  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22928 }
22929 template<>
22930 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22931  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22932  size_t item_size0=(CYCLUS_SHA1_SIZE);
22933  size_t item_size1key=shape[1];
22934  size_t valuelen1key;
22935  size_t item_size1val=(CYCLUS_SHA1_SIZE);
22936  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22937  size_t item_size2valval=sizeof(int);
22938  size_t total_item_size1val=item_size2valkey+item_size2valval;
22939  size_t total_item_size0=item_size1key+item_size1val;
22940  unsigned int count0=0;
22941  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22942  std::map<std::string, std::map<std::string, int>> fixed_val0;
22943  unsigned int pad_count0=0;
22944  for(;it0!=val0.end();++it0){
22945  std::string child1key=std::string(it0->first,0,item_size1key);
22946  fixed_val0[child1key] = it0->second;
22947  ++pad_count0;
22948 
22949  }
22950  hasher_.Clear();
22951  hasher_.Update(fixed_val0);
22952  Digest key0 = hasher_.digest();
22953  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_VL_STRING_INT, true);
22954  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_VL_STRING_INT, false);
22955  if (vlkeys_[VL_MAP_STRING_VL_MAP_VL_STRING_INT].count(key0) != 1) {
22956  hvl_t buf0 = VLValToBuf(fixed_val0);
22957  AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_VL_STRING_INT, key0);
22958  InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_VL_STRING_INT, key0, buf0);
22959  }
22960  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
22961 }
22962 template<>
22963 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
22964  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
22965  size_t item_size0=(CYCLUS_SHA1_SIZE);
22966  size_t item_size1key=CYCLUS_SHA1_SIZE;
22967  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(int))*shape[2]);
22968  size_t length1val=shape[2];
22969  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
22970  size_t item_size2valval=sizeof(int);
22971  size_t total_item_size1val=item_size2valkey+item_size2valval;
22972  size_t total_item_size0=item_size1key+item_size1val;
22973  unsigned int count0=0;
22974  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
22975  std::map<std::string, std::map<std::string, int>> fixed_val0;
22976  unsigned int pad_count0=0;
22977  for(;it0!=val0.end();++it0){
22978  std::map<std::string, int> child1val;
22979  unsigned int pad_count1val=0;
22980  std::map<std::string, int>::iterator it1val=it0->second.begin();
22981  for(;it1val!=it0->second.end();++it1val){
22982  child1val[it1val->first] = it1val->second;
22983  ++pad_count1val;
22984 
22985  }
22986  fixed_val0[it0->first] = child1val;
22987  ++pad_count0;
22988 
22989  }
22990  hasher_.Clear();
22991  hasher_.Update(fixed_val0);
22992  Digest key0 = hasher_.digest();
22993  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_VL_STRING_INT, true);
22994  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_VL_STRING_INT, false);
22995  if (vlkeys_[VL_MAP_VL_STRING_MAP_VL_STRING_INT].count(key0) != 1) {
22996  hvl_t buf0 = VLValToBuf(fixed_val0);
22997  AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_VL_STRING_INT, key0);
22998  InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_VL_STRING_INT, key0, buf0);
22999  }
23000  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
23001 }
23002 template<>
23003 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_MAP_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23004  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
23005  size_t item_size0=(CYCLUS_SHA1_SIZE);
23006  size_t item_size1key=CYCLUS_SHA1_SIZE;
23007  size_t item_size1val=(CYCLUS_SHA1_SIZE);
23008  size_t item_size2valkey=shape[3];
23009  size_t valuelen2valkey;
23010  size_t item_size2valval=sizeof(int);
23011  size_t total_item_size1val=item_size2valkey+item_size2valval;
23012  size_t total_item_size0=item_size1key+item_size1val;
23013  unsigned int count0=0;
23014  std::map<std::string, std::map<std::string, int>>::iterator it0=val0.begin();
23015  std::map<std::string, std::map<std::string, int>> fixed_val0;
23016  unsigned int pad_count0=0;
23017  for(;it0!=val0.end();++it0){
23018  std::map<std::string, int> child1val;
23019  unsigned int pad_count1val=0;
23020  std::map<std::string, int>::iterator it1val=it0->second.begin();
23021  for(;it1val!=it0->second.end();++it1val){
23022  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
23023  child1val[child2valkey] = it1val->second;
23024  ++pad_count1val;
23025 
23026  }
23027  fixed_val0[it0->first] = child1val;
23028  ++pad_count0;
23029 
23030  }
23031  hasher_.Clear();
23032  hasher_.Update(fixed_val0);
23033  Digest key0 = hasher_.digest();
23034  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_STRING_INT, true);
23035  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_STRING_INT, false);
23036  if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_STRING_INT].count(key0) != 1) {
23037  hvl_t buf0 = VLValToBuf(fixed_val0);
23038  AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_STRING_INT, key0);
23039  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_STRING_INT, key0, buf0);
23040  }
23041  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
23042 }
23043 template<>
23044 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23045  std::map<std::string, std::map<std::string, int>> val0=a->cast<std::map<std::string, std::map<std::string, int>>>();
23046  size_t item_size0=(CYCLUS_SHA1_SIZE);
23047  size_t item_size1key=CYCLUS_SHA1_SIZE;
23048  size_t item_size1val=(CYCLUS_SHA1_SIZE);
23049  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
23050  size_t item_size2valval=sizeof(int);
23051  size_t total_item_size1val=item_size2valkey+item_size2valval;
23052  size_t total_item_size0=item_size1key+item_size1val;
23053  hasher_.Clear();
23054  hasher_.Update(val0);
23055  Digest key0 = hasher_.digest();
23056  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT, true);
23057  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT, false);
23058  if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT].count(key0) != 1) {
23059  hvl_t buf0 = VLValToBuf(val0);
23060  AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT, key0);
23061  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT, key0, buf0);
23062  }
23063  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
23064 }
23065 template<>
23066 void Hdf5Back::WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23067  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> val0=a->cast<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>();
23068  size_t item_size0=((((((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5]))))*shape[0]);
23069  size_t length0=shape[0];
23070  size_t item_size1elem=((((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5])));
23071  size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23072  size_t item_size3elemfirstfirst=sizeof(double);
23073  size_t item_size3elemfirstsecond=sizeof(double);
23074  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23075  size_t item_size2elemsecond=((shape[6]+sizeof(double))*shape[5]);
23076  size_t length2elemsecond=shape[5];
23077  size_t item_size3elemsecondkey=shape[6];
23078  size_t valuelen3elemsecondkey;
23079  size_t item_size3elemsecondval=sizeof(double);
23080  size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23081  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23082  size_t total_item_size0=item_size1elem;
23083  if(total_item_size0*val0.size()>column){
23084  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator eraseit=val0.begin();
23085  std::advance(eraseit, column/total_item_size0);
23086  val0.erase(eraseit,val0.end());
23087 
23088  }
23089  unsigned int count0=0;
23090  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23091  for(;it0!=val0.end();++it0){
23092  unsigned int count1elem=0;
23093  unsigned int count2elemfirst=0;
23094  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0, &(it0->first.first), item_size3elemfirstfirst);
23095  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0+item_size3elemfirstfirst, &(it0->first.second), item_size3elemfirstsecond);
23096  unsigned int count2elemsecond=0;
23097  std::map<std::string, double>::iterator it2elemsecond=it0->second.begin();
23098  for(;it2elemsecond!=it0->second.end();++it2elemsecond){
23099  valuelen3elemsecondkey=std::min(it2elemsecond->first.size(), item_size3elemsecondkey);
23100  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, it2elemsecond->first.c_str(), valuelen3elemsecondkey);
23101  memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+valuelen3elemsecondkey, 0, item_size3elemsecondkey-valuelen3elemsecondkey);
23102  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondkey, &(it2elemsecond->second), item_size3elemsecondval);
23103  ++count2elemsecond;
23104 
23105  }
23106  memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+total_item_size2elemsecond*count2elemsecond, 0, total_item_size2elemsecond*(length2elemsecond-count2elemsecond));
23107  ++count0;
23108 
23109  }
23110  if(total_item_size0*length0<column){
23111  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23112 
23113  }
23114 }
23115 template<>
23116 void Hdf5Back::WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23117  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> val0=a->cast<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>();
23118  size_t item_size0=((((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]))))*shape[0]);
23119  size_t length0=shape[0];
23120  size_t item_size1elem=((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5])));
23121  size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23122  size_t item_size3elemfirstfirst=sizeof(double);
23123  size_t item_size3elemfirstsecond=sizeof(double);
23124  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23125  size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]);
23126  size_t length2elemsecond=shape[5];
23127  size_t item_size3elemsecondkey=CYCLUS_SHA1_SIZE;
23128  size_t item_size3elemsecondval=sizeof(double);
23129  size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23130  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23131  size_t total_item_size0=item_size1elem;
23132  if(total_item_size0*val0.size()>column){
23133  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator eraseit=val0.begin();
23134  std::advance(eraseit, column/total_item_size0);
23135  val0.erase(eraseit,val0.end());
23136 
23137  }
23138  unsigned int count0=0;
23139  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23140  for(;it0!=val0.end();++it0){
23141  unsigned int count1elem=0;
23142  unsigned int count2elemfirst=0;
23143  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0, &(it0->first.first), item_size3elemfirstfirst);
23144  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0+item_size3elemfirstfirst, &(it0->first.second), item_size3elemfirstsecond);
23145  unsigned int count2elemsecond=0;
23146  std::map<std::string, double>::iterator it2elemsecond=it0->second.begin();
23147  for(;it2elemsecond!=it0->second.end();++it2elemsecond){
23148  hasher_.Clear();
23149  hasher_.Update(it2elemsecond->first);
23150  Digest key3elemsecondkey = hasher_.digest();
23151  hid_t keysds3elemsecondkey = VLDataset(VL_STRING, true);
23152  hid_t valsds3elemsecondkey = VLDataset(VL_STRING, false);
23153  if (vlkeys_[VL_STRING].count(key3elemsecondkey) != 1) {
23154  AppendVLKey(keysds3elemsecondkey, VL_STRING, key3elemsecondkey);
23155  InsertVLVal(valsds3elemsecondkey, VL_STRING, key3elemsecondkey, it2elemsecond->first);
23156  }
23157  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, key3elemsecondkey.val, CYCLUS_SHA1_SIZE);
23158  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondkey, &(it2elemsecond->second), item_size3elemsecondval);
23159  ++count2elemsecond;
23160 
23161  }
23162  memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+total_item_size2elemsecond*count2elemsecond, 0, total_item_size2elemsecond*(length2elemsecond-count2elemsecond));
23163  ++count0;
23164 
23165  }
23166  if(total_item_size0*length0<column){
23167  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23168 
23169  }
23170 }
23171 template<>
23172 void Hdf5Back::WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23173  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> val0=a->cast<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>();
23174  size_t item_size0=((((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE))))*shape[0]);
23175  size_t length0=shape[0];
23176  size_t item_size1elem=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23177  size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23178  size_t item_size3elemfirstfirst=sizeof(double);
23179  size_t item_size3elemfirstsecond=sizeof(double);
23180  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23181  size_t item_size2elemsecond=(CYCLUS_SHA1_SIZE);
23182  size_t item_size3elemsecondkey=shape[6];
23183  size_t valuelen3elemsecondkey;
23184  size_t item_size3elemsecondval=sizeof(double);
23185  size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23186  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23187  size_t total_item_size0=item_size1elem;
23188  if(total_item_size0*val0.size()>column){
23189  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator eraseit=val0.begin();
23190  std::advance(eraseit, column/total_item_size0);
23191  val0.erase(eraseit,val0.end());
23192 
23193  }
23194  unsigned int count0=0;
23195  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23196  for(;it0!=val0.end();++it0){
23197  unsigned int count1elem=0;
23198  unsigned int count2elemfirst=0;
23199  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0, &(it0->first.first), item_size3elemfirstfirst);
23200  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0+item_size3elemfirstfirst, &(it0->first.second), item_size3elemfirstsecond);
23201  unsigned int count2elemsecond=0;
23202  std::map<std::string, double>::iterator it2elemsecond=it0->second.begin();
23203  std::map<std::string, double> fixed_val2elemsecond;
23204  unsigned int pad_count2elemsecond=0;
23205  for(;it2elemsecond!=it0->second.end();++it2elemsecond){
23206  std::string child3elemsecondkey=std::string(it2elemsecond->first,0,item_size3elemsecondkey);
23207  fixed_val2elemsecond[child3elemsecondkey] = it2elemsecond->second;
23208  ++pad_count2elemsecond;
23209 
23210  }
23211  hasher_.Clear();
23212  hasher_.Update(fixed_val2elemsecond);
23213  Digest key2elemsecond = hasher_.digest();
23214  hid_t keysds2elemsecond = VLDataset(VL_MAP_STRING_DOUBLE, true);
23215  hid_t valsds2elemsecond = VLDataset(VL_MAP_STRING_DOUBLE, false);
23216  if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key2elemsecond) != 1) {
23217  hvl_t buf2elemsecond = VLValToBuf(fixed_val2elemsecond);
23218  AppendVLKey(keysds2elemsecond, VL_MAP_STRING_DOUBLE, key2elemsecond);
23219  InsertVLVal(valsds2elemsecond, VL_MAP_STRING_DOUBLE, key2elemsecond, buf2elemsecond);
23220  }
23221  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst, key2elemsecond.val, CYCLUS_SHA1_SIZE);
23222  ++count0;
23223 
23224  }
23225  if(total_item_size0*length0<column){
23226  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23227 
23228  }
23229 }
23230 template<>
23231 void Hdf5Back::WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23232  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> val0=a->cast<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>();
23233  size_t item_size0=((((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE))))*shape[0]);
23234  size_t length0=shape[0];
23235  size_t item_size1elem=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23236  size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23237  size_t item_size3elemfirstfirst=sizeof(double);
23238  size_t item_size3elemfirstsecond=sizeof(double);
23239  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23240  size_t item_size2elemsecond=(CYCLUS_SHA1_SIZE);
23241  size_t item_size3elemsecondkey=CYCLUS_SHA1_SIZE;
23242  size_t item_size3elemsecondval=sizeof(double);
23243  size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23244  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23245  size_t total_item_size0=item_size1elem;
23246  if(total_item_size0*val0.size()>column){
23247  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator eraseit=val0.begin();
23248  std::advance(eraseit, column/total_item_size0);
23249  val0.erase(eraseit,val0.end());
23250 
23251  }
23252  unsigned int count0=0;
23253  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23254  for(;it0!=val0.end();++it0){
23255  unsigned int count1elem=0;
23256  unsigned int count2elemfirst=0;
23257  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0, &(it0->first.first), item_size3elemfirstfirst);
23258  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+(count2elemfirst*total_item_size2elemfirst)+0+item_size3elemfirstfirst, &(it0->first.second), item_size3elemfirstsecond);
23259  hasher_.Clear();
23260  hasher_.Update(it0->second);
23261  Digest key2elemsecond = hasher_.digest();
23262  hid_t keysds2elemsecond = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
23263  hid_t valsds2elemsecond = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
23264  if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key2elemsecond) != 1) {
23265  hvl_t buf2elemsecond = VLValToBuf(it0->second);
23266  AppendVLKey(keysds2elemsecond, VL_MAP_VL_STRING_DOUBLE, key2elemsecond);
23267  InsertVLVal(valsds2elemsecond, VL_MAP_VL_STRING_DOUBLE, key2elemsecond, buf2elemsecond);
23268  }
23269  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst, key2elemsecond.val, CYCLUS_SHA1_SIZE);
23270  ++count0;
23271 
23272  }
23273  if(total_item_size0*length0<column){
23274  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23275 
23276  }
23277 }
23278 template<>
23279 void Hdf5Back::WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23280  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> val0=a->cast<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>();
23281  size_t item_size0=(CYCLUS_SHA1_SIZE);
23282  size_t item_size1elem=((((sizeof(double)+sizeof(double)))+((shape[6]+sizeof(double))*shape[5])));
23283  size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23284  size_t item_size3elemfirstfirst=sizeof(double);
23285  size_t item_size3elemfirstsecond=sizeof(double);
23286  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23287  size_t item_size2elemsecond=((shape[6]+sizeof(double))*shape[5]);
23288  size_t length2elemsecond=shape[5];
23289  size_t item_size3elemsecondkey=shape[6];
23290  size_t valuelen3elemsecondkey;
23291  size_t item_size3elemsecondval=sizeof(double);
23292  size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23293  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23294  size_t total_item_size0=item_size1elem;
23295  unsigned int count0=0;
23296  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23297  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> fixed_val0;
23298  unsigned int pad_count0=0;
23299  for(;it0!=val0.end();++it0){
23300  std::pair<std::pair<double, double>, std::map<std::string, double>> child1elem;
23301  unsigned int pad_count1elem=0;
23302  std::pair<double, double> child2elemfirst;
23303  unsigned int pad_count2elemfirst=0;
23304  child2elemfirst = std::make_pair((*it0).first.first,(*it0).first.second);
23305  std::map<std::string, double> child2elemsecond;
23306  unsigned int pad_count2elemsecond=0;
23307  std::map<std::string, double>::iterator it2elemsecond=(*it0).second.begin();
23308  for(;it2elemsecond!=(*it0).second.end();++it2elemsecond){
23309  std::string child3elemsecondkey=std::string(it2elemsecond->first,0,item_size3elemsecondkey);
23310  child2elemsecond[child3elemsecondkey] = it2elemsecond->second;
23311  ++pad_count2elemsecond;
23312 
23313  }
23314  child1elem = std::make_pair(child2elemfirst,child2elemsecond);
23315  fixed_val0.push_back(child1elem);
23316  ++pad_count0;
23317 
23318  }
23319  hasher_.Clear();
23320  hasher_.Update(fixed_val0);
23321  Digest key0 = hasher_.digest();
23322  hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE, true);
23323  hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE, false);
23324  if (vlkeys_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE].count(key0) != 1) {
23325  hvl_t buf0 = VLValToBuf(fixed_val0);
23326  AppendVLKey(keysds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE, key0);
23327  InsertVLVal(valsds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE, key0, buf0);
23328  }
23329  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
23330 }
23331 template<>
23332 void Hdf5Back::WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23333  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> val0=a->cast<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>();
23334  size_t item_size0=(CYCLUS_SHA1_SIZE);
23335  size_t item_size1elem=((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5])));
23336  size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23337  size_t item_size3elemfirstfirst=sizeof(double);
23338  size_t item_size3elemfirstsecond=sizeof(double);
23339  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23340  size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[5]);
23341  size_t length2elemsecond=shape[5];
23342  size_t item_size3elemsecondkey=CYCLUS_SHA1_SIZE;
23343  size_t item_size3elemsecondval=sizeof(double);
23344  size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23345  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23346  size_t total_item_size0=item_size1elem;
23347  unsigned int count0=0;
23348  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23349  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> fixed_val0;
23350  unsigned int pad_count0=0;
23351  for(;it0!=val0.end();++it0){
23352  std::pair<std::pair<double, double>, std::map<std::string, double>> child1elem;
23353  unsigned int pad_count1elem=0;
23354  std::pair<double, double> child2elemfirst;
23355  unsigned int pad_count2elemfirst=0;
23356  child2elemfirst = std::make_pair((*it0).first.first,(*it0).first.second);
23357  std::map<std::string, double> child2elemsecond;
23358  unsigned int pad_count2elemsecond=0;
23359  std::map<std::string, double>::iterator it2elemsecond=(*it0).second.begin();
23360  for(;it2elemsecond!=(*it0).second.end();++it2elemsecond){
23361  child2elemsecond[it2elemsecond->first] = it2elemsecond->second;
23362  ++pad_count2elemsecond;
23363 
23364  }
23365  child1elem = std::make_pair(child2elemfirst,child2elemsecond);
23366  fixed_val0.push_back(child1elem);
23367  ++pad_count0;
23368 
23369  }
23370  hasher_.Clear();
23371  hasher_.Update(fixed_val0);
23372  Digest key0 = hasher_.digest();
23373  hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE, true);
23374  hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE, false);
23375  if (vlkeys_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
23376  hvl_t buf0 = VLValToBuf(fixed_val0);
23377  AppendVLKey(keysds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE, key0);
23378  InsertVLVal(valsds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE, key0, buf0);
23379  }
23380  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
23381 }
23382 template<>
23383 void Hdf5Back::WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23384  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> val0=a->cast<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>();
23385  size_t item_size0=(CYCLUS_SHA1_SIZE);
23386  size_t item_size1elem=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23387  size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23388  size_t item_size3elemfirstfirst=sizeof(double);
23389  size_t item_size3elemfirstsecond=sizeof(double);
23390  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23391  size_t item_size2elemsecond=(CYCLUS_SHA1_SIZE);
23392  size_t item_size3elemsecondkey=shape[6];
23393  size_t valuelen3elemsecondkey;
23394  size_t item_size3elemsecondval=sizeof(double);
23395  size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23396  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23397  size_t total_item_size0=item_size1elem;
23398  unsigned int count0=0;
23399  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::iterator it0=val0.begin();
23400  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> fixed_val0;
23401  unsigned int pad_count0=0;
23402  for(;it0!=val0.end();++it0){
23403  std::pair<std::pair<double, double>, std::map<std::string, double>> child1elem;
23404  unsigned int pad_count1elem=0;
23405  std::pair<double, double> child2elemfirst;
23406  unsigned int pad_count2elemfirst=0;
23407  child2elemfirst = std::make_pair((*it0).first.first,(*it0).first.second);
23408  std::map<std::string, double> child2elemsecond;
23409  unsigned int pad_count2elemsecond=0;
23410  std::map<std::string, double>::iterator it2elemsecond=(*it0).second.begin();
23411  for(;it2elemsecond!=(*it0).second.end();++it2elemsecond){
23412  std::string child3elemsecondkey=std::string(it2elemsecond->first,0,item_size3elemsecondkey);
23413  child2elemsecond[child3elemsecondkey] = it2elemsecond->second;
23414  ++pad_count2elemsecond;
23415 
23416  }
23417  child1elem = std::make_pair(child2elemfirst,child2elemsecond);
23418  fixed_val0.push_back(child1elem);
23419  ++pad_count0;
23420 
23421  }
23422  hasher_.Clear();
23423  hasher_.Update(fixed_val0);
23424  Digest key0 = hasher_.digest();
23425  hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE, true);
23426  hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE, false);
23427  if (vlkeys_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE].count(key0) != 1) {
23428  hvl_t buf0 = VLValToBuf(fixed_val0);
23429  AppendVLKey(keysds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE, key0);
23430  InsertVLVal(valsds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE, key0, buf0);
23431  }
23432  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
23433 }
23434 template<>
23435 void Hdf5Back::WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23436  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> val0=a->cast<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>();
23437  size_t item_size0=(CYCLUS_SHA1_SIZE);
23438  size_t item_size1elem=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23439  size_t item_size2elemfirst=((sizeof(double)+sizeof(double)));
23440  size_t item_size3elemfirstfirst=sizeof(double);
23441  size_t item_size3elemfirstsecond=sizeof(double);
23442  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
23443  size_t item_size2elemsecond=(CYCLUS_SHA1_SIZE);
23444  size_t item_size3elemsecondkey=CYCLUS_SHA1_SIZE;
23445  size_t item_size3elemsecondval=sizeof(double);
23446  size_t total_item_size2elemsecond=item_size3elemsecondkey+item_size3elemsecondval;
23447  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23448  size_t total_item_size0=item_size1elem;
23449  hasher_.Clear();
23450  hasher_.Update(val0);
23451  Digest key0 = hasher_.digest();
23452  hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE, true);
23453  hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE, false);
23454  if (vlkeys_[VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
23455  hvl_t buf0 = VLValToBuf(val0);
23457  InsertVLVal(valsds0, VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE, key0, buf0);
23458  }
23459  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
23460 }
23461 template<>
23462 void Hdf5Back::WriteToBuf<PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23463  std::pair<int, std::pair<std::string, std::string>> val0=a->cast<std::pair<int, std::pair<std::string, std::string>>>();
23464  size_t item_size0=((sizeof(int)+((shape[3]+shape[4]))));
23465  size_t item_size1first=sizeof(int);
23466  size_t item_size1second=((shape[3]+shape[4]));
23467  size_t item_size2secondfirst=shape[3];
23468  size_t valuelen2secondfirst;
23469  size_t item_size2secondsecond=shape[4];
23470  size_t valuelen2secondsecond;
23471  size_t total_item_size1second=item_size2secondfirst+item_size2secondsecond;
23472  size_t total_item_size0=item_size1first+item_size1second;
23473  unsigned int count0=0;
23474  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23475  unsigned int count1second=0;
23476  valuelen2secondfirst=std::min(val0.second.first.size(), item_size2secondfirst);
23477  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, val0.second.first.c_str(), valuelen2secondfirst);
23478  memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+valuelen2secondfirst, 0, item_size2secondfirst-valuelen2secondfirst);
23479  valuelen2secondsecond=std::min(val0.second.second.size(), item_size2secondsecond);
23480  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst, val0.second.second.c_str(), valuelen2secondsecond);
23481  memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst+valuelen2secondsecond, 0, item_size2secondsecond-valuelen2secondsecond);
23482 }
23483 template<>
23484 void Hdf5Back::WriteToBuf<PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23485  std::pair<int, std::pair<std::string, std::string>> val0=a->cast<std::pair<int, std::pair<std::string, std::string>>>();
23486  size_t item_size0=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[4]))));
23487  size_t item_size1first=sizeof(int);
23488  size_t item_size1second=((CYCLUS_SHA1_SIZE+shape[4]));
23489  size_t item_size2secondfirst=CYCLUS_SHA1_SIZE;
23490  size_t item_size2secondsecond=shape[4];
23491  size_t valuelen2secondsecond;
23492  size_t total_item_size1second=item_size2secondfirst+item_size2secondsecond;
23493  size_t total_item_size0=item_size1first+item_size1second;
23494  unsigned int count0=0;
23495  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23496  unsigned int count1second=0;
23497  hasher_.Clear();
23498  hasher_.Update(val0.second.first);
23499  Digest key2secondfirst = hasher_.digest();
23500  hid_t keysds2secondfirst = VLDataset(VL_STRING, true);
23501  hid_t valsds2secondfirst = VLDataset(VL_STRING, false);
23502  if (vlkeys_[VL_STRING].count(key2secondfirst) != 1) {
23503  AppendVLKey(keysds2secondfirst, VL_STRING, key2secondfirst);
23504  InsertVLVal(valsds2secondfirst, VL_STRING, key2secondfirst, val0.second.first);
23505  }
23506  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, key2secondfirst.val, CYCLUS_SHA1_SIZE);
23507  valuelen2secondsecond=std::min(val0.second.second.size(), item_size2secondsecond);
23508  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst, val0.second.second.c_str(), valuelen2secondsecond);
23509  memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst+valuelen2secondsecond, 0, item_size2secondsecond-valuelen2secondsecond);
23510 }
23511 template<>
23512 void Hdf5Back::WriteToBuf<PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23513  std::pair<int, std::pair<std::string, std::string>> val0=a->cast<std::pair<int, std::pair<std::string, std::string>>>();
23514  size_t item_size0=((sizeof(int)+((shape[3]+CYCLUS_SHA1_SIZE))));
23515  size_t item_size1first=sizeof(int);
23516  size_t item_size1second=((shape[3]+CYCLUS_SHA1_SIZE));
23517  size_t item_size2secondfirst=shape[3];
23518  size_t valuelen2secondfirst;
23519  size_t item_size2secondsecond=CYCLUS_SHA1_SIZE;
23520  size_t total_item_size1second=item_size2secondfirst+item_size2secondsecond;
23521  size_t total_item_size0=item_size1first+item_size1second;
23522  unsigned int count0=0;
23523  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23524  unsigned int count1second=0;
23525  valuelen2secondfirst=std::min(val0.second.first.size(), item_size2secondfirst);
23526  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, val0.second.first.c_str(), valuelen2secondfirst);
23527  memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+valuelen2secondfirst, 0, item_size2secondfirst-valuelen2secondfirst);
23528  hasher_.Clear();
23529  hasher_.Update(val0.second.second);
23530  Digest key2secondsecond = hasher_.digest();
23531  hid_t keysds2secondsecond = VLDataset(VL_STRING, true);
23532  hid_t valsds2secondsecond = VLDataset(VL_STRING, false);
23533  if (vlkeys_[VL_STRING].count(key2secondsecond) != 1) {
23534  AppendVLKey(keysds2secondsecond, VL_STRING, key2secondsecond);
23535  InsertVLVal(valsds2secondsecond, VL_STRING, key2secondsecond, val0.second.second);
23536  }
23537  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst, key2secondsecond.val, CYCLUS_SHA1_SIZE);
23538 }
23539 template<>
23540 void Hdf5Back::WriteToBuf<PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23541  std::pair<int, std::pair<std::string, std::string>> val0=a->cast<std::pair<int, std::pair<std::string, std::string>>>();
23542  size_t item_size0=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
23543  size_t item_size1first=sizeof(int);
23544  size_t item_size1second=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
23545  size_t item_size2secondfirst=CYCLUS_SHA1_SIZE;
23546  size_t item_size2secondsecond=CYCLUS_SHA1_SIZE;
23547  size_t total_item_size1second=item_size2secondfirst+item_size2secondsecond;
23548  size_t total_item_size0=item_size1first+item_size1second;
23549  unsigned int count0=0;
23550  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23551  unsigned int count1second=0;
23552  hasher_.Clear();
23553  hasher_.Update(val0.second.first);
23554  Digest key2secondfirst = hasher_.digest();
23555  hid_t keysds2secondfirst = VLDataset(VL_STRING, true);
23556  hid_t valsds2secondfirst = VLDataset(VL_STRING, false);
23557  if (vlkeys_[VL_STRING].count(key2secondfirst) != 1) {
23558  AppendVLKey(keysds2secondfirst, VL_STRING, key2secondfirst);
23559  InsertVLVal(valsds2secondfirst, VL_STRING, key2secondfirst, val0.second.first);
23560  }
23561  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, key2secondfirst.val, CYCLUS_SHA1_SIZE);
23562  hasher_.Clear();
23563  hasher_.Update(val0.second.second);
23564  Digest key2secondsecond = hasher_.digest();
23565  hid_t keysds2secondsecond = VLDataset(VL_STRING, true);
23566  hid_t valsds2secondsecond = VLDataset(VL_STRING, false);
23567  if (vlkeys_[VL_STRING].count(key2secondsecond) != 1) {
23568  AppendVLKey(keysds2secondsecond, VL_STRING, key2secondsecond);
23569  InsertVLVal(valsds2secondsecond, VL_STRING, key2secondsecond, val0.second.second);
23570  }
23571  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondfirst, key2secondsecond.val, CYCLUS_SHA1_SIZE);
23572 }
23573 template<>
23574 void Hdf5Back::WriteToBuf<PAIR_DOUBLE_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23575  std::pair<double, double> val0=a->cast<std::pair<double, double>>();
23576  size_t item_size0=((sizeof(double)+sizeof(double)));
23577  size_t item_size1first=sizeof(double);
23578  size_t item_size1second=sizeof(double);
23579  size_t total_item_size0=item_size1first+item_size1second;
23580  unsigned int count0=0;
23581  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23582  memcpy(buf+(count0*total_item_size0)+0+item_size1first, &(val0.second), item_size1second);
23583 }
23584 template<>
23585 void Hdf5Back::WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23586  std::pair<std::pair<double, double>, std::map<std::string, double>> val0=a->cast<std::pair<std::pair<double, double>, std::map<std::string, double>>>();
23587  size_t item_size0=((((sizeof(double)+sizeof(double)))+((shape[5]+sizeof(double))*shape[4])));
23588  size_t item_size1first=((sizeof(double)+sizeof(double)));
23589  size_t item_size2firstfirst=sizeof(double);
23590  size_t item_size2firstsecond=sizeof(double);
23591  size_t total_item_size1first=item_size2firstfirst+item_size2firstsecond;
23592  size_t item_size1second=((shape[5]+sizeof(double))*shape[4]);
23593  size_t length1second=shape[4];
23594  size_t item_size2secondkey=shape[5];
23595  size_t valuelen2secondkey;
23596  size_t item_size2secondval=sizeof(double);
23597  size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23598  size_t total_item_size0=item_size1first+item_size1second;
23599  unsigned int count0=0;
23600  unsigned int count1first=0;
23601  memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0, &(val0.first.first), item_size2firstfirst);
23602  memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0+item_size2firstfirst, &(val0.first.second), item_size2firstsecond);
23603  unsigned int count1second=0;
23604  std::map<std::string, double>::iterator it1second=val0.second.begin();
23605  for(;it1second!=val0.second.end();++it1second){
23606  valuelen2secondkey=std::min(it1second->first.size(), item_size2secondkey);
23607  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, it1second->first.c_str(), valuelen2secondkey);
23608  memset(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+valuelen2secondkey, 0, item_size2secondkey-valuelen2secondkey);
23609  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondkey, &(it1second->second), item_size2secondval);
23610  ++count1second;
23611 
23612  }
23613  memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
23614 }
23615 template<>
23616 void Hdf5Back::WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23617  std::pair<std::pair<double, double>, std::map<std::string, double>> val0=a->cast<std::pair<std::pair<double, double>, std::map<std::string, double>>>();
23618  size_t item_size0=((((sizeof(double)+sizeof(double)))+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[4])));
23619  size_t item_size1first=((sizeof(double)+sizeof(double)));
23620  size_t item_size2firstfirst=sizeof(double);
23621  size_t item_size2firstsecond=sizeof(double);
23622  size_t total_item_size1first=item_size2firstfirst+item_size2firstsecond;
23623  size_t item_size1second=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[4]);
23624  size_t length1second=shape[4];
23625  size_t item_size2secondkey=CYCLUS_SHA1_SIZE;
23626  size_t item_size2secondval=sizeof(double);
23627  size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23628  size_t total_item_size0=item_size1first+item_size1second;
23629  unsigned int count0=0;
23630  unsigned int count1first=0;
23631  memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0, &(val0.first.first), item_size2firstfirst);
23632  memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0+item_size2firstfirst, &(val0.first.second), item_size2firstsecond);
23633  unsigned int count1second=0;
23634  std::map<std::string, double>::iterator it1second=val0.second.begin();
23635  for(;it1second!=val0.second.end();++it1second){
23636  hasher_.Clear();
23637  hasher_.Update(it1second->first);
23638  Digest key2secondkey = hasher_.digest();
23639  hid_t keysds2secondkey = VLDataset(VL_STRING, true);
23640  hid_t valsds2secondkey = VLDataset(VL_STRING, false);
23641  if (vlkeys_[VL_STRING].count(key2secondkey) != 1) {
23642  AppendVLKey(keysds2secondkey, VL_STRING, key2secondkey);
23643  InsertVLVal(valsds2secondkey, VL_STRING, key2secondkey, it1second->first);
23644  }
23645  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, key2secondkey.val, CYCLUS_SHA1_SIZE);
23646  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondkey, &(it1second->second), item_size2secondval);
23647  ++count1second;
23648 
23649  }
23650  memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
23651 }
23652 template<>
23653 void Hdf5Back::WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23654  std::pair<std::pair<double, double>, std::map<std::string, double>> val0=a->cast<std::pair<std::pair<double, double>, std::map<std::string, double>>>();
23655  size_t item_size0=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23656  size_t item_size1first=((sizeof(double)+sizeof(double)));
23657  size_t item_size2firstfirst=sizeof(double);
23658  size_t item_size2firstsecond=sizeof(double);
23659  size_t total_item_size1first=item_size2firstfirst+item_size2firstsecond;
23660  size_t item_size1second=(CYCLUS_SHA1_SIZE);
23661  size_t item_size2secondkey=shape[5];
23662  size_t valuelen2secondkey;
23663  size_t item_size2secondval=sizeof(double);
23664  size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23665  size_t total_item_size0=item_size1first+item_size1second;
23666  unsigned int count0=0;
23667  unsigned int count1first=0;
23668  memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0, &(val0.first.first), item_size2firstfirst);
23669  memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0+item_size2firstfirst, &(val0.first.second), item_size2firstsecond);
23670  unsigned int count1second=0;
23671  std::map<std::string, double>::iterator it1second=val0.second.begin();
23672  std::map<std::string, double> fixed_val1second;
23673  unsigned int pad_count1second=0;
23674  for(;it1second!=val0.second.end();++it1second){
23675  std::string child2secondkey=std::string(it1second->first,0,item_size2secondkey);
23676  fixed_val1second[child2secondkey] = it1second->second;
23677  ++pad_count1second;
23678 
23679  }
23680  hasher_.Clear();
23681  hasher_.Update(fixed_val1second);
23682  Digest key1second = hasher_.digest();
23683  hid_t keysds1second = VLDataset(VL_MAP_STRING_DOUBLE, true);
23684  hid_t valsds1second = VLDataset(VL_MAP_STRING_DOUBLE, false);
23685  if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key1second) != 1) {
23686  hvl_t buf1second = VLValToBuf(fixed_val1second);
23687  AppendVLKey(keysds1second, VL_MAP_STRING_DOUBLE, key1second);
23688  InsertVLVal(valsds1second, VL_MAP_STRING_DOUBLE, key1second, buf1second);
23689  }
23690  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
23691 }
23692 template<>
23693 void Hdf5Back::WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23694  std::pair<std::pair<double, double>, std::map<std::string, double>> val0=a->cast<std::pair<std::pair<double, double>, std::map<std::string, double>>>();
23695  size_t item_size0=((((sizeof(double)+sizeof(double)))+(CYCLUS_SHA1_SIZE)));
23696  size_t item_size1first=((sizeof(double)+sizeof(double)));
23697  size_t item_size2firstfirst=sizeof(double);
23698  size_t item_size2firstsecond=sizeof(double);
23699  size_t total_item_size1first=item_size2firstfirst+item_size2firstsecond;
23700  size_t item_size1second=(CYCLUS_SHA1_SIZE);
23701  size_t item_size2secondkey=CYCLUS_SHA1_SIZE;
23702  size_t item_size2secondval=sizeof(double);
23703  size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23704  size_t total_item_size0=item_size1first+item_size1second;
23705  unsigned int count0=0;
23706  unsigned int count1first=0;
23707  memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0, &(val0.first.first), item_size2firstfirst);
23708  memcpy(buf+(count0*total_item_size0)+0+(count1first*total_item_size1first)+0+item_size2firstfirst, &(val0.first.second), item_size2firstsecond);
23709  hasher_.Clear();
23710  hasher_.Update(val0.second);
23711  Digest key1second = hasher_.digest();
23712  hid_t keysds1second = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
23713  hid_t valsds1second = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
23714  if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1second) != 1) {
23715  hvl_t buf1second = VLValToBuf(val0.second);
23716  AppendVLKey(keysds1second, VL_MAP_VL_STRING_DOUBLE, key1second);
23717  InsertVLVal(valsds1second, VL_MAP_VL_STRING_DOUBLE, key1second, buf1second);
23718  }
23719  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
23720 }
23721 template<>
23722 void Hdf5Back::WriteToBuf<PAIR_DOUBLE_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23723  std::pair<double, std::map<int, double>> val0=a->cast<std::pair<double, std::map<int, double>>>();
23724  size_t item_size0=((sizeof(double)+((sizeof(int)+sizeof(double))*shape[2])));
23725  size_t item_size1first=sizeof(double);
23726  size_t item_size1second=((sizeof(int)+sizeof(double))*shape[2]);
23727  size_t length1second=shape[2];
23728  size_t item_size2secondkey=sizeof(int);
23729  size_t item_size2secondval=sizeof(double);
23730  size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23731  size_t total_item_size0=item_size1first+item_size1second;
23732  unsigned int count0=0;
23733  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23734  unsigned int count1second=0;
23735  std::map<int, double>::iterator it1second=val0.second.begin();
23736  for(;it1second!=val0.second.end();++it1second){
23737  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0, &(it1second->first), item_size2secondkey);
23738  memcpy(buf+(count0*total_item_size0)+0+item_size1first+(count1second*total_item_size1second)+0+item_size2secondkey, &(it1second->second), item_size2secondval);
23739  ++count1second;
23740 
23741  }
23742  memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
23743 }
23744 template<>
23745 void Hdf5Back::WriteToBuf<PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23746  std::pair<double, std::map<int, double>> val0=a->cast<std::pair<double, std::map<int, double>>>();
23747  size_t item_size0=((sizeof(double)+(CYCLUS_SHA1_SIZE)));
23748  size_t item_size1first=sizeof(double);
23749  size_t item_size1second=(CYCLUS_SHA1_SIZE);
23750  size_t item_size2secondkey=sizeof(int);
23751  size_t item_size2secondval=sizeof(double);
23752  size_t total_item_size1second=item_size2secondkey+item_size2secondval;
23753  size_t total_item_size0=item_size1first+item_size1second;
23754  unsigned int count0=0;
23755  memcpy(buf+(count0*total_item_size0)+0, &(val0.first), item_size1first);
23756  hasher_.Clear();
23757  hasher_.Update(val0.second);
23758  Digest key1second = hasher_.digest();
23759  hid_t keysds1second = VLDataset(VL_MAP_INT_DOUBLE, true);
23760  hid_t valsds1second = VLDataset(VL_MAP_INT_DOUBLE, false);
23761  if (vlkeys_[VL_MAP_INT_DOUBLE].count(key1second) != 1) {
23762  hvl_t buf1second = VLValToBuf(val0.second);
23763  AppendVLKey(keysds1second, VL_MAP_INT_DOUBLE, key1second);
23764  InsertVLVal(valsds1second, VL_MAP_INT_DOUBLE, key1second, buf1second);
23765  }
23766  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
23767 }
23768 template<>
23769 void Hdf5Back::WriteToBuf<VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23770  std::vector<std::pair<int, std::pair<std::string, std::string>>> val0=a->cast<std::vector<std::pair<int, std::pair<std::string, std::string>>>>();
23771  size_t item_size0=((((sizeof(int)+((shape[4]+shape[5])))))*shape[0]);
23772  size_t length0=shape[0];
23773  size_t item_size1elem=((sizeof(int)+((shape[4]+shape[5]))));
23774  size_t item_size2elemfirst=sizeof(int);
23775  size_t item_size2elemsecond=((shape[4]+shape[5]));
23776  size_t item_size3elemsecondfirst=shape[4];
23777  size_t valuelen3elemsecondfirst;
23778  size_t item_size3elemsecondsecond=shape[5];
23779  size_t valuelen3elemsecondsecond;
23780  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23781  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23782  size_t total_item_size0=item_size1elem;
23783  if(total_item_size0*val0.size()>column){
23784  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator eraseit=val0.begin();
23785  std::advance(eraseit, column/total_item_size0);
23786  val0.erase(eraseit,val0.end());
23787 
23788  }
23789  unsigned int count0=0;
23790  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23791  for(;it0!=val0.end();++it0){
23792  unsigned int count1elem=0;
23793  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
23794  unsigned int count2elemsecond=0;
23795  valuelen3elemsecondfirst=std::min(it0->second.first.size(), item_size3elemsecondfirst);
23796  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, it0->second.first.c_str(), valuelen3elemsecondfirst);
23797  memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+valuelen3elemsecondfirst, 0, item_size3elemsecondfirst-valuelen3elemsecondfirst);
23798  valuelen3elemsecondsecond=std::min(it0->second.second.size(), item_size3elemsecondsecond);
23799  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst, it0->second.second.c_str(), valuelen3elemsecondsecond);
23800  memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst+valuelen3elemsecondsecond, 0, item_size3elemsecondsecond-valuelen3elemsecondsecond);
23801  ++count0;
23802 
23803  }
23804  if(total_item_size0*length0<column){
23805  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23806 
23807  }
23808 }
23809 template<>
23810 void Hdf5Back::WriteToBuf<VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23811  std::vector<std::pair<int, std::pair<std::string, std::string>>> val0=a->cast<std::vector<std::pair<int, std::pair<std::string, std::string>>>>();
23812  size_t item_size0=((((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5])))))*shape[0]);
23813  size_t length0=shape[0];
23814  size_t item_size1elem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5]))));
23815  size_t item_size2elemfirst=sizeof(int);
23816  size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+shape[5]));
23817  size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
23818  size_t item_size3elemsecondsecond=shape[5];
23819  size_t valuelen3elemsecondsecond;
23820  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23821  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23822  size_t total_item_size0=item_size1elem;
23823  if(total_item_size0*val0.size()>column){
23824  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator eraseit=val0.begin();
23825  std::advance(eraseit, column/total_item_size0);
23826  val0.erase(eraseit,val0.end());
23827 
23828  }
23829  unsigned int count0=0;
23830  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23831  for(;it0!=val0.end();++it0){
23832  unsigned int count1elem=0;
23833  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
23834  unsigned int count2elemsecond=0;
23835  hasher_.Clear();
23836  hasher_.Update(it0->second.first);
23837  Digest key3elemsecondfirst = hasher_.digest();
23838  hid_t keysds3elemsecondfirst = VLDataset(VL_STRING, true);
23839  hid_t valsds3elemsecondfirst = VLDataset(VL_STRING, false);
23840  if (vlkeys_[VL_STRING].count(key3elemsecondfirst) != 1) {
23841  AppendVLKey(keysds3elemsecondfirst, VL_STRING, key3elemsecondfirst);
23842  InsertVLVal(valsds3elemsecondfirst, VL_STRING, key3elemsecondfirst, it0->second.first);
23843  }
23844  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, key3elemsecondfirst.val, CYCLUS_SHA1_SIZE);
23845  valuelen3elemsecondsecond=std::min(it0->second.second.size(), item_size3elemsecondsecond);
23846  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst, it0->second.second.c_str(), valuelen3elemsecondsecond);
23847  memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst+valuelen3elemsecondsecond, 0, item_size3elemsecondsecond-valuelen3elemsecondsecond);
23848  ++count0;
23849 
23850  }
23851  if(total_item_size0*length0<column){
23852  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23853 
23854  }
23855 }
23856 template<>
23857 void Hdf5Back::WriteToBuf<VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23858  std::vector<std::pair<int, std::pair<std::string, std::string>>> val0=a->cast<std::vector<std::pair<int, std::pair<std::string, std::string>>>>();
23859  size_t item_size0=((((sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE)))))*shape[0]);
23860  size_t length0=shape[0];
23861  size_t item_size1elem=((sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE))));
23862  size_t item_size2elemfirst=sizeof(int);
23863  size_t item_size2elemsecond=((shape[4]+CYCLUS_SHA1_SIZE));
23864  size_t item_size3elemsecondfirst=shape[4];
23865  size_t valuelen3elemsecondfirst;
23866  size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
23867  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23868  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23869  size_t total_item_size0=item_size1elem;
23870  if(total_item_size0*val0.size()>column){
23871  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator eraseit=val0.begin();
23872  std::advance(eraseit, column/total_item_size0);
23873  val0.erase(eraseit,val0.end());
23874 
23875  }
23876  unsigned int count0=0;
23877  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23878  for(;it0!=val0.end();++it0){
23879  unsigned int count1elem=0;
23880  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
23881  unsigned int count2elemsecond=0;
23882  valuelen3elemsecondfirst=std::min(it0->second.first.size(), item_size3elemsecondfirst);
23883  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, it0->second.first.c_str(), valuelen3elemsecondfirst);
23884  memset(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+valuelen3elemsecondfirst, 0, item_size3elemsecondfirst-valuelen3elemsecondfirst);
23885  hasher_.Clear();
23886  hasher_.Update(it0->second.second);
23887  Digest key3elemsecondsecond = hasher_.digest();
23888  hid_t keysds3elemsecondsecond = VLDataset(VL_STRING, true);
23889  hid_t valsds3elemsecondsecond = VLDataset(VL_STRING, false);
23890  if (vlkeys_[VL_STRING].count(key3elemsecondsecond) != 1) {
23891  AppendVLKey(keysds3elemsecondsecond, VL_STRING, key3elemsecondsecond);
23892  InsertVLVal(valsds3elemsecondsecond, VL_STRING, key3elemsecondsecond, it0->second.second);
23893  }
23894  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst, key3elemsecondsecond.val, CYCLUS_SHA1_SIZE);
23895  ++count0;
23896 
23897  }
23898  if(total_item_size0*length0<column){
23899  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23900 
23901  }
23902 }
23903 template<>
23904 void Hdf5Back::WriteToBuf<VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23905  std::vector<std::pair<int, std::pair<std::string, std::string>>> val0=a->cast<std::vector<std::pair<int, std::pair<std::string, std::string>>>>();
23906  size_t item_size0=((((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE)))))*shape[0]);
23907  size_t length0=shape[0];
23908  size_t item_size1elem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
23909  size_t item_size2elemfirst=sizeof(int);
23910  size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
23911  size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
23912  size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
23913  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23914  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23915  size_t total_item_size0=item_size1elem;
23916  if(total_item_size0*val0.size()>column){
23917  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator eraseit=val0.begin();
23918  std::advance(eraseit, column/total_item_size0);
23919  val0.erase(eraseit,val0.end());
23920 
23921  }
23922  unsigned int count0=0;
23923  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23924  for(;it0!=val0.end();++it0){
23925  unsigned int count1elem=0;
23926  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0, &(it0->first), item_size2elemfirst);
23927  unsigned int count2elemsecond=0;
23928  hasher_.Clear();
23929  hasher_.Update(it0->second.first);
23930  Digest key3elemsecondfirst = hasher_.digest();
23931  hid_t keysds3elemsecondfirst = VLDataset(VL_STRING, true);
23932  hid_t valsds3elemsecondfirst = VLDataset(VL_STRING, false);
23933  if (vlkeys_[VL_STRING].count(key3elemsecondfirst) != 1) {
23934  AppendVLKey(keysds3elemsecondfirst, VL_STRING, key3elemsecondfirst);
23935  InsertVLVal(valsds3elemsecondfirst, VL_STRING, key3elemsecondfirst, it0->second.first);
23936  }
23937  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0, key3elemsecondfirst.val, CYCLUS_SHA1_SIZE);
23938  hasher_.Clear();
23939  hasher_.Update(it0->second.second);
23940  Digest key3elemsecondsecond = hasher_.digest();
23941  hid_t keysds3elemsecondsecond = VLDataset(VL_STRING, true);
23942  hid_t valsds3elemsecondsecond = VLDataset(VL_STRING, false);
23943  if (vlkeys_[VL_STRING].count(key3elemsecondsecond) != 1) {
23944  AppendVLKey(keysds3elemsecondsecond, VL_STRING, key3elemsecondsecond);
23945  InsertVLVal(valsds3elemsecondsecond, VL_STRING, key3elemsecondsecond, it0->second.second);
23946  }
23947  memcpy(buf+item_size1elem*count0+(count1elem*total_item_size1elem)+0+item_size2elemfirst+(count2elemsecond*total_item_size2elemsecond)+0+item_size3elemsecondfirst, key3elemsecondsecond.val, CYCLUS_SHA1_SIZE);
23948  ++count0;
23949 
23950  }
23951  if(total_item_size0*length0<column){
23952  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
23953 
23954  }
23955 }
23956 template<>
23957 void Hdf5Back::WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
23958  std::vector<std::pair<int, std::pair<std::string, std::string>>> val0=a->cast<std::vector<std::pair<int, std::pair<std::string, std::string>>>>();
23959  size_t item_size0=(CYCLUS_SHA1_SIZE);
23960  size_t item_size1elem=((sizeof(int)+((shape[4]+shape[5]))));
23961  size_t item_size2elemfirst=sizeof(int);
23962  size_t item_size2elemsecond=((shape[4]+shape[5]));
23963  size_t item_size3elemsecondfirst=shape[4];
23964  size_t valuelen3elemsecondfirst;
23965  size_t item_size3elemsecondsecond=shape[5];
23966  size_t valuelen3elemsecondsecond;
23967  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
23968  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
23969  size_t total_item_size0=item_size1elem;
23970  unsigned int count0=0;
23971  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
23972  std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val0;
23973  unsigned int pad_count0=0;
23974  for(;it0!=val0.end();++it0){
23975  std::pair<int, std::pair<std::string, std::string>> child1elem;
23976  unsigned int pad_count1elem=0;
23977  std::pair<std::string, std::string> child2elemsecond;
23978  unsigned int pad_count2elemsecond=0;
23979  std::string child3elemsecondfirst=std::string((*it0).second.first,0,item_size3elemsecondfirst);
23980  std::string child3elemsecondsecond=std::string((*it0).second.second,0,item_size3elemsecondsecond);
23981  child2elemsecond = std::make_pair(child3elemsecondfirst,child3elemsecondsecond);
23982  child1elem = std::make_pair((*it0).first,child2elemsecond);
23983  fixed_val0.push_back(child1elem);
23984  ++pad_count0;
23985 
23986  }
23987  hasher_.Clear();
23988  hasher_.Update(fixed_val0);
23989  Digest key0 = hasher_.digest();
23990  hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, true);
23991  hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, false);
23992  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_STRING].count(key0) != 1) {
23993  hvl_t buf0 = VLValToBuf(fixed_val0);
23994  AppendVLKey(keysds0, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0);
23995  InsertVLVal(valsds0, VL_VECTOR_PAIR_INT_PAIR_STRING_STRING, key0, buf0);
23996  }
23997  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
23998 }
23999 template<>
24000 void Hdf5Back::WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24001  std::vector<std::pair<int, std::pair<std::string, std::string>>> val0=a->cast<std::vector<std::pair<int, std::pair<std::string, std::string>>>>();
24002  size_t item_size0=(CYCLUS_SHA1_SIZE);
24003  size_t item_size1elem=((sizeof(int)+((CYCLUS_SHA1_SIZE+shape[5]))));
24004  size_t item_size2elemfirst=sizeof(int);
24005  size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+shape[5]));
24006  size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
24007  size_t item_size3elemsecondsecond=shape[5];
24008  size_t valuelen3elemsecondsecond;
24009  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
24010  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
24011  size_t total_item_size0=item_size1elem;
24012  unsigned int count0=0;
24013  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
24014  std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val0;
24015  unsigned int pad_count0=0;
24016  for(;it0!=val0.end();++it0){
24017  std::pair<int, std::pair<std::string, std::string>> child1elem;
24018  unsigned int pad_count1elem=0;
24019  std::pair<std::string, std::string> child2elemsecond;
24020  unsigned int pad_count2elemsecond=0;
24021  std::string child3elemsecondsecond=std::string((*it0).second.second,0,item_size3elemsecondsecond);
24022  child2elemsecond = std::make_pair((*it0).second.first,child3elemsecondsecond);
24023  child1elem = std::make_pair((*it0).first,child2elemsecond);
24024  fixed_val0.push_back(child1elem);
24025  ++pad_count0;
24026 
24027  }
24028  hasher_.Clear();
24029  hasher_.Update(fixed_val0);
24030  Digest key0 = hasher_.digest();
24031  hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, true);
24032  hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, false);
24033  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING].count(key0) != 1) {
24034  hvl_t buf0 = VLValToBuf(fixed_val0);
24035  AppendVLKey(keysds0, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0);
24036  InsertVLVal(valsds0, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING, key0, buf0);
24037  }
24038  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
24039 }
24040 template<>
24041 void Hdf5Back::WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24042  std::vector<std::pair<int, std::pair<std::string, std::string>>> val0=a->cast<std::vector<std::pair<int, std::pair<std::string, std::string>>>>();
24043  size_t item_size0=(CYCLUS_SHA1_SIZE);
24044  size_t item_size1elem=((sizeof(int)+((shape[4]+CYCLUS_SHA1_SIZE))));
24045  size_t item_size2elemfirst=sizeof(int);
24046  size_t item_size2elemsecond=((shape[4]+CYCLUS_SHA1_SIZE));
24047  size_t item_size3elemsecondfirst=shape[4];
24048  size_t valuelen3elemsecondfirst;
24049  size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
24050  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
24051  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
24052  size_t total_item_size0=item_size1elem;
24053  unsigned int count0=0;
24054  std::vector<std::pair<int, std::pair<std::string, std::string>>>::iterator it0=val0.begin();
24055  std::vector<std::pair<int, std::pair<std::string, std::string>>> fixed_val0;
24056  unsigned int pad_count0=0;
24057  for(;it0!=val0.end();++it0){
24058  std::pair<int, std::pair<std::string, std::string>> child1elem;
24059  unsigned int pad_count1elem=0;
24060  std::pair<std::string, std::string> child2elemsecond;
24061  unsigned int pad_count2elemsecond=0;
24062  std::string child3elemsecondfirst=std::string((*it0).second.first,0,item_size3elemsecondfirst);
24063  child2elemsecond = std::make_pair(child3elemsecondfirst,(*it0).second.second);
24064  child1elem = std::make_pair((*it0).first,child2elemsecond);
24065  fixed_val0.push_back(child1elem);
24066  ++pad_count0;
24067 
24068  }
24069  hasher_.Clear();
24070  hasher_.Update(fixed_val0);
24071  Digest key0 = hasher_.digest();
24072  hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, true);
24073  hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, false);
24074  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING].count(key0) != 1) {
24075  hvl_t buf0 = VLValToBuf(fixed_val0);
24076  AppendVLKey(keysds0, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0);
24077  InsertVLVal(valsds0, VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING, key0, buf0);
24078  }
24079  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
24080 }
24081 template<>
24082 void Hdf5Back::WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24083  std::vector<std::pair<int, std::pair<std::string, std::string>>> val0=a->cast<std::vector<std::pair<int, std::pair<std::string, std::string>>>>();
24084  size_t item_size0=(CYCLUS_SHA1_SIZE);
24085  size_t item_size1elem=((sizeof(int)+((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))));
24086  size_t item_size2elemfirst=sizeof(int);
24087  size_t item_size2elemsecond=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
24088  size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
24089  size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
24090  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
24091  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
24092  size_t total_item_size0=item_size1elem;
24093  hasher_.Clear();
24094  hasher_.Update(val0);
24095  Digest key0 = hasher_.digest();
24096  hid_t keysds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
24097  hid_t valsds0 = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
24098  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key0) != 1) {
24099  hvl_t buf0 = VLValToBuf(val0);
24100  AppendVLKey(keysds0, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0);
24101  InsertVLVal(valsds0, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key0, buf0);
24102  }
24103  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
24104 }
24105 template<>
24106 void Hdf5Back::WriteToBuf<PAIR_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24107  std::pair<std::string, std::vector<double>> val0=a->cast<std::pair<std::string, std::vector<double>>>();
24108  size_t item_size0=((shape[1]+((sizeof(double))*shape[2])));
24109  size_t item_size1first=shape[1];
24110  size_t valuelen1first;
24111  size_t item_size1second=((sizeof(double))*shape[2]);
24112  size_t length1second=shape[2];
24113  size_t item_size2secondelem=sizeof(double);
24114  size_t total_item_size1second=item_size2secondelem;
24115  size_t total_item_size0=item_size1first+item_size1second;
24116  unsigned int count0=0;
24117  valuelen1first=std::min(val0.first.size(), item_size1first);
24118  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
24119  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
24120  unsigned int count1second=0;
24121  std::vector<double>::iterator it1second=val0.second.begin();
24122  for(;it1second!=val0.second.end();++it1second){
24123  memcpy(buf+(count0*total_item_size0)+0+item_size1first+item_size2secondelem*count1second, &(*it1second), item_size2secondelem);
24124  ++count1second;
24125 
24126  }
24127  memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
24128 }
24129 template<>
24130 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24131  std::pair<std::string, std::vector<double>> val0=a->cast<std::pair<std::string, std::vector<double>>>();
24132  size_t item_size0=((CYCLUS_SHA1_SIZE+((sizeof(double))*shape[2])));
24133  size_t item_size1first=CYCLUS_SHA1_SIZE;
24134  size_t item_size1second=((sizeof(double))*shape[2]);
24135  size_t length1second=shape[2];
24136  size_t item_size2secondelem=sizeof(double);
24137  size_t total_item_size1second=item_size2secondelem;
24138  size_t total_item_size0=item_size1first+item_size1second;
24139  unsigned int count0=0;
24140  hasher_.Clear();
24141  hasher_.Update(val0.first);
24142  Digest key1first = hasher_.digest();
24143  hid_t keysds1first = VLDataset(VL_STRING, true);
24144  hid_t valsds1first = VLDataset(VL_STRING, false);
24145  if (vlkeys_[VL_STRING].count(key1first) != 1) {
24146  AppendVLKey(keysds1first, VL_STRING, key1first);
24147  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
24148  }
24149  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
24150  unsigned int count1second=0;
24151  std::vector<double>::iterator it1second=val0.second.begin();
24152  for(;it1second!=val0.second.end();++it1second){
24153  memcpy(buf+(count0*total_item_size0)+0+item_size1first+item_size2secondelem*count1second, &(*it1second), item_size2secondelem);
24154  ++count1second;
24155 
24156  }
24157  memset(buf+(count0*total_item_size0)+0+item_size1first+total_item_size1second*count1second, 0, total_item_size1second*(length1second-count1second));
24158 }
24159 template<>
24160 void Hdf5Back::WriteToBuf<PAIR_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24161  std::pair<std::string, std::vector<double>> val0=a->cast<std::pair<std::string, std::vector<double>>>();
24162  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE)));
24163  size_t item_size1first=shape[1];
24164  size_t valuelen1first;
24165  size_t item_size1second=(CYCLUS_SHA1_SIZE);
24166  size_t item_size2secondelem=sizeof(double);
24167  size_t total_item_size1second=item_size2secondelem;
24168  size_t total_item_size0=item_size1first+item_size1second;
24169  unsigned int count0=0;
24170  valuelen1first=std::min(val0.first.size(), item_size1first);
24171  memcpy(buf+(count0*total_item_size0)+0, val0.first.c_str(), valuelen1first);
24172  memset(buf+(count0*total_item_size0)+0+valuelen1first, 0, item_size1first-valuelen1first);
24173  hasher_.Clear();
24174  hasher_.Update(val0.second);
24175  Digest key1second = hasher_.digest();
24176  hid_t keysds1second = VLDataset(VL_VECTOR_DOUBLE, true);
24177  hid_t valsds1second = VLDataset(VL_VECTOR_DOUBLE, false);
24178  if (vlkeys_[VL_VECTOR_DOUBLE].count(key1second) != 1) {
24179  hvl_t buf1second = VLValToBuf(val0.second);
24180  AppendVLKey(keysds1second, VL_VECTOR_DOUBLE, key1second);
24181  InsertVLVal(valsds1second, VL_VECTOR_DOUBLE, key1second, buf1second);
24182  }
24183  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
24184 }
24185 template<>
24186 void Hdf5Back::WriteToBuf<PAIR_VL_STRING_VL_VECTOR_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24187  std::pair<std::string, std::vector<double>> val0=a->cast<std::pair<std::string, std::vector<double>>>();
24188  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE)));
24189  size_t item_size1first=CYCLUS_SHA1_SIZE;
24190  size_t item_size1second=(CYCLUS_SHA1_SIZE);
24191  size_t item_size2secondelem=sizeof(double);
24192  size_t total_item_size1second=item_size2secondelem;
24193  size_t total_item_size0=item_size1first+item_size1second;
24194  unsigned int count0=0;
24195  hasher_.Clear();
24196  hasher_.Update(val0.first);
24197  Digest key1first = hasher_.digest();
24198  hid_t keysds1first = VLDataset(VL_STRING, true);
24199  hid_t valsds1first = VLDataset(VL_STRING, false);
24200  if (vlkeys_[VL_STRING].count(key1first) != 1) {
24201  AppendVLKey(keysds1first, VL_STRING, key1first);
24202  InsertVLVal(valsds1first, VL_STRING, key1first, val0.first);
24203  }
24204  memcpy(buf+(count0*total_item_size0)+0, key1first.val, CYCLUS_SHA1_SIZE);
24205  hasher_.Clear();
24206  hasher_.Update(val0.second);
24207  Digest key1second = hasher_.digest();
24208  hid_t keysds1second = VLDataset(VL_VECTOR_DOUBLE, true);
24209  hid_t valsds1second = VLDataset(VL_VECTOR_DOUBLE, false);
24210  if (vlkeys_[VL_VECTOR_DOUBLE].count(key1second) != 1) {
24211  hvl_t buf1second = VLValToBuf(val0.second);
24212  AppendVLKey(keysds1second, VL_VECTOR_DOUBLE, key1second);
24213  InsertVLVal(valsds1second, VL_VECTOR_DOUBLE, key1second, buf1second);
24214  }
24215  memcpy(buf+(count0*total_item_size0)+0+item_size1first, key1second.val, CYCLUS_SHA1_SIZE);
24216 }
24217 template<>
24218 void Hdf5Back::WriteToBuf<MAP_PAIR_STRING_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24219  std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24220  size_t item_size0=((((shape[2]+shape[3]))+sizeof(int))*shape[0]);
24221  size_t length0=shape[0];
24222  size_t item_size1key=((shape[2]+shape[3]));
24223  size_t item_size2keyfirst=shape[2];
24224  size_t valuelen2keyfirst;
24225  size_t item_size2keysecond=shape[3];
24226  size_t valuelen2keysecond;
24227  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24228  size_t item_size1val=sizeof(int);
24229  size_t total_item_size0=item_size1key+item_size1val;
24230  if(total_item_size0*val0.size()>column){
24231  std::map<std::pair<std::string, std::string>, int>::iterator eraseit=val0.begin();
24232  std::advance(eraseit, column/total_item_size0);
24233  val0.erase(eraseit,val0.end());
24234 
24235  }
24236  unsigned int count0=0;
24237  std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24238  for(;it0!=val0.end();++it0){
24239  unsigned int count1key=0;
24240  valuelen2keyfirst=std::min(it0->first.first.size(), item_size2keyfirst);
24241  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, it0->first.first.c_str(), valuelen2keyfirst);
24242  memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+valuelen2keyfirst, 0, item_size2keyfirst-valuelen2keyfirst);
24243  valuelen2keysecond=std::min(it0->first.second.size(), item_size2keysecond);
24244  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, it0->first.second.c_str(), valuelen2keysecond);
24245  memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst+valuelen2keysecond, 0, item_size2keysecond-valuelen2keysecond);
24246  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
24247  ++count0;
24248 
24249  }
24250  if(total_item_size0*length0<column){
24251  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24252 
24253  }
24254 }
24255 template<>
24256 void Hdf5Back::WriteToBuf<MAP_PAIR_STRING_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24257  std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24258  size_t item_size0=((((shape[2]+CYCLUS_SHA1_SIZE))+sizeof(int))*shape[0]);
24259  size_t length0=shape[0];
24260  size_t item_size1key=((shape[2]+CYCLUS_SHA1_SIZE));
24261  size_t item_size2keyfirst=shape[2];
24262  size_t valuelen2keyfirst;
24263  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
24264  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24265  size_t item_size1val=sizeof(int);
24266  size_t total_item_size0=item_size1key+item_size1val;
24267  if(total_item_size0*val0.size()>column){
24268  std::map<std::pair<std::string, std::string>, int>::iterator eraseit=val0.begin();
24269  std::advance(eraseit, column/total_item_size0);
24270  val0.erase(eraseit,val0.end());
24271 
24272  }
24273  unsigned int count0=0;
24274  std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24275  for(;it0!=val0.end();++it0){
24276  unsigned int count1key=0;
24277  valuelen2keyfirst=std::min(it0->first.first.size(), item_size2keyfirst);
24278  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, it0->first.first.c_str(), valuelen2keyfirst);
24279  memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+valuelen2keyfirst, 0, item_size2keyfirst-valuelen2keyfirst);
24280  hasher_.Clear();
24281  hasher_.Update(it0->first.second);
24282  Digest key2keysecond = hasher_.digest();
24283  hid_t keysds2keysecond = VLDataset(VL_STRING, true);
24284  hid_t valsds2keysecond = VLDataset(VL_STRING, false);
24285  if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
24286  AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
24287  InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
24288  }
24289  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, key2keysecond.val, CYCLUS_SHA1_SIZE);
24290  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
24291  ++count0;
24292 
24293  }
24294  if(total_item_size0*length0<column){
24295  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24296 
24297  }
24298 }
24299 template<>
24300 void Hdf5Back::WriteToBuf<MAP_PAIR_VL_STRING_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24301  std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24302  size_t item_size0=((((CYCLUS_SHA1_SIZE+shape[3]))+sizeof(int))*shape[0]);
24303  size_t length0=shape[0];
24304  size_t item_size1key=((CYCLUS_SHA1_SIZE+shape[3]));
24305  size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
24306  size_t item_size2keysecond=shape[3];
24307  size_t valuelen2keysecond;
24308  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24309  size_t item_size1val=sizeof(int);
24310  size_t total_item_size0=item_size1key+item_size1val;
24311  if(total_item_size0*val0.size()>column){
24312  std::map<std::pair<std::string, std::string>, int>::iterator eraseit=val0.begin();
24313  std::advance(eraseit, column/total_item_size0);
24314  val0.erase(eraseit,val0.end());
24315 
24316  }
24317  unsigned int count0=0;
24318  std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24319  for(;it0!=val0.end();++it0){
24320  unsigned int count1key=0;
24321  hasher_.Clear();
24322  hasher_.Update(it0->first.first);
24323  Digest key2keyfirst = hasher_.digest();
24324  hid_t keysds2keyfirst = VLDataset(VL_STRING, true);
24325  hid_t valsds2keyfirst = VLDataset(VL_STRING, false);
24326  if (vlkeys_[VL_STRING].count(key2keyfirst) != 1) {
24327  AppendVLKey(keysds2keyfirst, VL_STRING, key2keyfirst);
24328  InsertVLVal(valsds2keyfirst, VL_STRING, key2keyfirst, it0->first.first);
24329  }
24330  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, key2keyfirst.val, CYCLUS_SHA1_SIZE);
24331  valuelen2keysecond=std::min(it0->first.second.size(), item_size2keysecond);
24332  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, it0->first.second.c_str(), valuelen2keysecond);
24333  memset(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst+valuelen2keysecond, 0, item_size2keysecond-valuelen2keysecond);
24334  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
24335  ++count0;
24336 
24337  }
24338  if(total_item_size0*length0<column){
24339  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24340 
24341  }
24342 }
24343 template<>
24344 void Hdf5Back::WriteToBuf<MAP_PAIR_VL_STRING_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24345  std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24346  size_t item_size0=((((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE))+sizeof(int))*shape[0]);
24347  size_t length0=shape[0];
24348  size_t item_size1key=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
24349  size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
24350  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
24351  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24352  size_t item_size1val=sizeof(int);
24353  size_t total_item_size0=item_size1key+item_size1val;
24354  if(total_item_size0*val0.size()>column){
24355  std::map<std::pair<std::string, std::string>, int>::iterator eraseit=val0.begin();
24356  std::advance(eraseit, column/total_item_size0);
24357  val0.erase(eraseit,val0.end());
24358 
24359  }
24360  unsigned int count0=0;
24361  std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24362  for(;it0!=val0.end();++it0){
24363  unsigned int count1key=0;
24364  hasher_.Clear();
24365  hasher_.Update(it0->first.first);
24366  Digest key2keyfirst = hasher_.digest();
24367  hid_t keysds2keyfirst = VLDataset(VL_STRING, true);
24368  hid_t valsds2keyfirst = VLDataset(VL_STRING, false);
24369  if (vlkeys_[VL_STRING].count(key2keyfirst) != 1) {
24370  AppendVLKey(keysds2keyfirst, VL_STRING, key2keyfirst);
24371  InsertVLVal(valsds2keyfirst, VL_STRING, key2keyfirst, it0->first.first);
24372  }
24373  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0, key2keyfirst.val, CYCLUS_SHA1_SIZE);
24374  hasher_.Clear();
24375  hasher_.Update(it0->first.second);
24376  Digest key2keysecond = hasher_.digest();
24377  hid_t keysds2keysecond = VLDataset(VL_STRING, true);
24378  hid_t valsds2keysecond = VLDataset(VL_STRING, false);
24379  if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
24380  AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
24381  InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
24382  }
24383  memcpy(buf+(count0*total_item_size0)+0+(count1key*total_item_size1key)+0+item_size2keyfirst, key2keysecond.val, CYCLUS_SHA1_SIZE);
24384  memcpy(buf+(count0*total_item_size0)+0+item_size1key, &(it0->second), item_size1val);
24385  ++count0;
24386 
24387  }
24388  if(total_item_size0*length0<column){
24389  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24390 
24391  }
24392 }
24393 template<>
24394 void Hdf5Back::WriteToBuf<VL_MAP_PAIR_STRING_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24395  std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24396  size_t item_size0=(CYCLUS_SHA1_SIZE);
24397  size_t item_size1key=((shape[2]+shape[3]));
24398  size_t item_size2keyfirst=shape[2];
24399  size_t valuelen2keyfirst;
24400  size_t item_size2keysecond=shape[3];
24401  size_t valuelen2keysecond;
24402  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24403  size_t item_size1val=sizeof(int);
24404  size_t total_item_size0=item_size1key+item_size1val;
24405  unsigned int count0=0;
24406  std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24407  std::map<std::pair<std::string, std::string>, int> fixed_val0;
24408  unsigned int pad_count0=0;
24409  for(;it0!=val0.end();++it0){
24410  std::pair<std::string, std::string> child1key;
24411  unsigned int pad_count1key=0;
24412  std::string child2keyfirst=std::string(it0->first.first,0,item_size2keyfirst);
24413  std::string child2keysecond=std::string(it0->first.second,0,item_size2keysecond);
24414  child1key = std::make_pair(child2keyfirst,child2keysecond);
24415  fixed_val0[child1key] = it0->second;
24416  ++pad_count0;
24417 
24418  }
24419  hasher_.Clear();
24420  hasher_.Update(fixed_val0);
24421  Digest key0 = hasher_.digest();
24422  hid_t keysds0 = VLDataset(VL_MAP_PAIR_STRING_STRING_INT, true);
24423  hid_t valsds0 = VLDataset(VL_MAP_PAIR_STRING_STRING_INT, false);
24424  if (vlkeys_[VL_MAP_PAIR_STRING_STRING_INT].count(key0) != 1) {
24425  hvl_t buf0 = VLValToBuf(fixed_val0);
24426  AppendVLKey(keysds0, VL_MAP_PAIR_STRING_STRING_INT, key0);
24427  InsertVLVal(valsds0, VL_MAP_PAIR_STRING_STRING_INT, key0, buf0);
24428  }
24429  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
24430 }
24431 template<>
24432 void Hdf5Back::WriteToBuf<VL_MAP_PAIR_STRING_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24433  std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24434  size_t item_size0=(CYCLUS_SHA1_SIZE);
24435  size_t item_size1key=((shape[2]+CYCLUS_SHA1_SIZE));
24436  size_t item_size2keyfirst=shape[2];
24437  size_t valuelen2keyfirst;
24438  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
24439  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24440  size_t item_size1val=sizeof(int);
24441  size_t total_item_size0=item_size1key+item_size1val;
24442  unsigned int count0=0;
24443  std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24444  std::map<std::pair<std::string, std::string>, int> fixed_val0;
24445  unsigned int pad_count0=0;
24446  for(;it0!=val0.end();++it0){
24447  std::pair<std::string, std::string> child1key;
24448  unsigned int pad_count1key=0;
24449  std::string child2keyfirst=std::string(it0->first.first,0,item_size2keyfirst);
24450  child1key = std::make_pair(child2keyfirst,it0->first.second);
24451  fixed_val0[child1key] = it0->second;
24452  ++pad_count0;
24453 
24454  }
24455  hasher_.Clear();
24456  hasher_.Update(fixed_val0);
24457  Digest key0 = hasher_.digest();
24458  hid_t keysds0 = VLDataset(VL_MAP_PAIR_STRING_VL_STRING_INT, true);
24459  hid_t valsds0 = VLDataset(VL_MAP_PAIR_STRING_VL_STRING_INT, false);
24460  if (vlkeys_[VL_MAP_PAIR_STRING_VL_STRING_INT].count(key0) != 1) {
24461  hvl_t buf0 = VLValToBuf(fixed_val0);
24462  AppendVLKey(keysds0, VL_MAP_PAIR_STRING_VL_STRING_INT, key0);
24463  InsertVLVal(valsds0, VL_MAP_PAIR_STRING_VL_STRING_INT, key0, buf0);
24464  }
24465  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
24466 }
24467 template<>
24468 void Hdf5Back::WriteToBuf<VL_MAP_PAIR_VL_STRING_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24469  std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24470  size_t item_size0=(CYCLUS_SHA1_SIZE);
24471  size_t item_size1key=((CYCLUS_SHA1_SIZE+shape[3]));
24472  size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
24473  size_t item_size2keysecond=shape[3];
24474  size_t valuelen2keysecond;
24475  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24476  size_t item_size1val=sizeof(int);
24477  size_t total_item_size0=item_size1key+item_size1val;
24478  unsigned int count0=0;
24479  std::map<std::pair<std::string, std::string>, int>::iterator it0=val0.begin();
24480  std::map<std::pair<std::string, std::string>, int> fixed_val0;
24481  unsigned int pad_count0=0;
24482  for(;it0!=val0.end();++it0){
24483  std::pair<std::string, std::string> child1key;
24484  unsigned int pad_count1key=0;
24485  std::string child2keysecond=std::string(it0->first.second,0,item_size2keysecond);
24486  child1key = std::make_pair(it0->first.first,child2keysecond);
24487  fixed_val0[child1key] = it0->second;
24488  ++pad_count0;
24489 
24490  }
24491  hasher_.Clear();
24492  hasher_.Update(fixed_val0);
24493  Digest key0 = hasher_.digest();
24494  hid_t keysds0 = VLDataset(VL_MAP_PAIR_VL_STRING_STRING_INT, true);
24495  hid_t valsds0 = VLDataset(VL_MAP_PAIR_VL_STRING_STRING_INT, false);
24496  if (vlkeys_[VL_MAP_PAIR_VL_STRING_STRING_INT].count(key0) != 1) {
24497  hvl_t buf0 = VLValToBuf(fixed_val0);
24498  AppendVLKey(keysds0, VL_MAP_PAIR_VL_STRING_STRING_INT, key0);
24499  InsertVLVal(valsds0, VL_MAP_PAIR_VL_STRING_STRING_INT, key0, buf0);
24500  }
24501  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
24502 }
24503 template<>
24504 void Hdf5Back::WriteToBuf<VL_MAP_PAIR_VL_STRING_VL_STRING_INT>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24505  std::map<std::pair<std::string, std::string>, int> val0=a->cast<std::map<std::pair<std::string, std::string>, int>>();
24506  size_t item_size0=(CYCLUS_SHA1_SIZE);
24507  size_t item_size1key=((CYCLUS_SHA1_SIZE+CYCLUS_SHA1_SIZE));
24508  size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
24509  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
24510  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
24511  size_t item_size1val=sizeof(int);
24512  size_t total_item_size0=item_size1key+item_size1val;
24513  hasher_.Clear();
24514  hasher_.Update(val0);
24515  Digest key0 = hasher_.digest();
24516  hid_t keysds0 = VLDataset(VL_MAP_PAIR_VL_STRING_VL_STRING_INT, true);
24517  hid_t valsds0 = VLDataset(VL_MAP_PAIR_VL_STRING_VL_STRING_INT, false);
24518  if (vlkeys_[VL_MAP_PAIR_VL_STRING_VL_STRING_INT].count(key0) != 1) {
24519  hvl_t buf0 = VLValToBuf(val0);
24520  AppendVLKey(keysds0, VL_MAP_PAIR_VL_STRING_VL_STRING_INT, key0);
24521  InsertVLVal(valsds0, VL_MAP_PAIR_VL_STRING_VL_STRING_INT, key0, buf0);
24522  }
24523  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
24524 }
24525 template<>
24526 void Hdf5Back::WriteToBuf<MAP_STRING_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24527  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24528  size_t item_size0=((shape[1]+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
24529  size_t length0=shape[0];
24530  size_t item_size1key=shape[1];
24531  size_t valuelen1key;
24532  size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
24533  size_t length1val=shape[2];
24534  size_t item_size2valkey=shape[3];
24535  size_t valuelen2valkey;
24536  size_t item_size2valval=sizeof(double);
24537  size_t total_item_size1val=item_size2valkey+item_size2valval;
24538  size_t total_item_size0=item_size1key+item_size1val;
24539  if(total_item_size0*val0.size()>column){
24540  std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24541  std::advance(eraseit, column/total_item_size0);
24542  val0.erase(eraseit,val0.end());
24543 
24544  }
24545  unsigned int count0=0;
24546  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24547  for(;it0!=val0.end();++it0){
24548  valuelen1key=std::min(it0->first.size(), item_size1key);
24549  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
24550  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
24551  unsigned int count1val=0;
24552  std::map<std::string, double>::iterator it1val=it0->second.begin();
24553  for(;it1val!=it0->second.end();++it1val){
24554  valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
24555  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
24556  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
24557  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
24558  ++count1val;
24559 
24560  }
24561  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
24562  ++count0;
24563 
24564  }
24565  if(total_item_size0*length0<column){
24566  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24567 
24568  }
24569 }
24570 template<>
24571 void Hdf5Back::WriteToBuf<MAP_STRING_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24572  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24573  size_t item_size0=((shape[1]+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
24574  size_t length0=shape[0];
24575  size_t item_size1key=shape[1];
24576  size_t valuelen1key;
24577  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
24578  size_t length1val=shape[2];
24579  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
24580  size_t item_size2valval=sizeof(double);
24581  size_t total_item_size1val=item_size2valkey+item_size2valval;
24582  size_t total_item_size0=item_size1key+item_size1val;
24583  if(total_item_size0*val0.size()>column){
24584  std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24585  std::advance(eraseit, column/total_item_size0);
24586  val0.erase(eraseit,val0.end());
24587 
24588  }
24589  unsigned int count0=0;
24590  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24591  for(;it0!=val0.end();++it0){
24592  valuelen1key=std::min(it0->first.size(), item_size1key);
24593  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
24594  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
24595  unsigned int count1val=0;
24596  std::map<std::string, double>::iterator it1val=it0->second.begin();
24597  for(;it1val!=it0->second.end();++it1val){
24598  hasher_.Clear();
24599  hasher_.Update(it1val->first);
24600  Digest key2valkey = hasher_.digest();
24601  hid_t keysds2valkey = VLDataset(VL_STRING, true);
24602  hid_t valsds2valkey = VLDataset(VL_STRING, false);
24603  if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
24604  AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
24605  InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
24606  }
24607  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.val, CYCLUS_SHA1_SIZE);
24608  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
24609  ++count1val;
24610 
24611  }
24612  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
24613  ++count0;
24614 
24615  }
24616  if(total_item_size0*length0<column){
24617  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24618 
24619  }
24620 }
24621 template<>
24622 void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24623  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24624  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
24625  size_t length0=shape[0];
24626  size_t item_size1key=shape[1];
24627  size_t valuelen1key;
24628  size_t item_size1val=(CYCLUS_SHA1_SIZE);
24629  size_t item_size2valkey=shape[3];
24630  size_t valuelen2valkey;
24631  size_t item_size2valval=sizeof(double);
24632  size_t total_item_size1val=item_size2valkey+item_size2valval;
24633  size_t total_item_size0=item_size1key+item_size1val;
24634  if(total_item_size0*val0.size()>column){
24635  std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24636  std::advance(eraseit, column/total_item_size0);
24637  val0.erase(eraseit,val0.end());
24638 
24639  }
24640  unsigned int count0=0;
24641  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24642  for(;it0!=val0.end();++it0){
24643  valuelen1key=std::min(it0->first.size(), item_size1key);
24644  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
24645  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
24646  unsigned int count1val=0;
24647  std::map<std::string, double>::iterator it1val=it0->second.begin();
24648  std::map<std::string, double> fixed_val1val;
24649  unsigned int pad_count1val=0;
24650  for(;it1val!=it0->second.end();++it1val){
24651  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
24652  fixed_val1val[child2valkey] = it1val->second;
24653  ++pad_count1val;
24654 
24655  }
24656  hasher_.Clear();
24657  hasher_.Update(fixed_val1val);
24658  Digest key1val = hasher_.digest();
24659  hid_t keysds1val = VLDataset(VL_MAP_STRING_DOUBLE, true);
24660  hid_t valsds1val = VLDataset(VL_MAP_STRING_DOUBLE, false);
24661  if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key1val) != 1) {
24662  hvl_t buf1val = VLValToBuf(fixed_val1val);
24663  AppendVLKey(keysds1val, VL_MAP_STRING_DOUBLE, key1val);
24664  InsertVLVal(valsds1val, VL_MAP_STRING_DOUBLE, key1val, buf1val);
24665  }
24666  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
24667  ++count0;
24668 
24669  }
24670  if(total_item_size0*length0<column){
24671  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24672 
24673  }
24674 }
24675 template<>
24676 void Hdf5Back::WriteToBuf<MAP_STRING_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24677  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24678  size_t item_size0=((shape[1]+(CYCLUS_SHA1_SIZE))*shape[0]);
24679  size_t length0=shape[0];
24680  size_t item_size1key=shape[1];
24681  size_t valuelen1key;
24682  size_t item_size1val=(CYCLUS_SHA1_SIZE);
24683  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
24684  size_t item_size2valval=sizeof(double);
24685  size_t total_item_size1val=item_size2valkey+item_size2valval;
24686  size_t total_item_size0=item_size1key+item_size1val;
24687  if(total_item_size0*val0.size()>column){
24688  std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24689  std::advance(eraseit, column/total_item_size0);
24690  val0.erase(eraseit,val0.end());
24691 
24692  }
24693  unsigned int count0=0;
24694  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24695  for(;it0!=val0.end();++it0){
24696  valuelen1key=std::min(it0->first.size(), item_size1key);
24697  memcpy(buf+(count0*total_item_size0)+0, it0->first.c_str(), valuelen1key);
24698  memset(buf+(count0*total_item_size0)+0+valuelen1key, 0, item_size1key-valuelen1key);
24699  hasher_.Clear();
24700  hasher_.Update(it0->second);
24701  Digest key1val = hasher_.digest();
24702  hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
24703  hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
24704  if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
24705  hvl_t buf1val = VLValToBuf(it0->second);
24706  AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
24707  InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
24708  }
24709  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
24710  ++count0;
24711 
24712  }
24713  if(total_item_size0*length0<column){
24714  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24715 
24716  }
24717 }
24718 template<>
24719 void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24720  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24721  size_t item_size0=((CYCLUS_SHA1_SIZE+((shape[3]+sizeof(double))*shape[2]))*shape[0]);
24722  size_t length0=shape[0];
24723  size_t item_size1key=CYCLUS_SHA1_SIZE;
24724  size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
24725  size_t length1val=shape[2];
24726  size_t item_size2valkey=shape[3];
24727  size_t valuelen2valkey;
24728  size_t item_size2valval=sizeof(double);
24729  size_t total_item_size1val=item_size2valkey+item_size2valval;
24730  size_t total_item_size0=item_size1key+item_size1val;
24731  if(total_item_size0*val0.size()>column){
24732  std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24733  std::advance(eraseit, column/total_item_size0);
24734  val0.erase(eraseit,val0.end());
24735 
24736  }
24737  unsigned int count0=0;
24738  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24739  for(;it0!=val0.end();++it0){
24740  hasher_.Clear();
24741  hasher_.Update(it0->first);
24742  Digest key1key = hasher_.digest();
24743  hid_t keysds1key = VLDataset(VL_STRING, true);
24744  hid_t valsds1key = VLDataset(VL_STRING, false);
24745  if (vlkeys_[VL_STRING].count(key1key) != 1) {
24746  AppendVLKey(keysds1key, VL_STRING, key1key);
24747  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
24748  }
24749  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
24750  unsigned int count1val=0;
24751  std::map<std::string, double>::iterator it1val=it0->second.begin();
24752  for(;it1val!=it0->second.end();++it1val){
24753  valuelen2valkey=std::min(it1val->first.size(), item_size2valkey);
24754  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, it1val->first.c_str(), valuelen2valkey);
24755  memset(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+valuelen2valkey, 0, item_size2valkey-valuelen2valkey);
24756  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
24757  ++count1val;
24758 
24759  }
24760  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
24761  ++count0;
24762 
24763  }
24764  if(total_item_size0*length0<column){
24765  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24766 
24767  }
24768 }
24769 template<>
24770 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24771  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24772  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
24773  size_t length0=shape[0];
24774  size_t item_size1key=CYCLUS_SHA1_SIZE;
24775  size_t item_size1val=(CYCLUS_SHA1_SIZE);
24776  size_t item_size2valkey=shape[3];
24777  size_t valuelen2valkey;
24778  size_t item_size2valval=sizeof(double);
24779  size_t total_item_size1val=item_size2valkey+item_size2valval;
24780  size_t total_item_size0=item_size1key+item_size1val;
24781  if(total_item_size0*val0.size()>column){
24782  std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24783  std::advance(eraseit, column/total_item_size0);
24784  val0.erase(eraseit,val0.end());
24785 
24786  }
24787  unsigned int count0=0;
24788  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24789  for(;it0!=val0.end();++it0){
24790  hasher_.Clear();
24791  hasher_.Update(it0->first);
24792  Digest key1key = hasher_.digest();
24793  hid_t keysds1key = VLDataset(VL_STRING, true);
24794  hid_t valsds1key = VLDataset(VL_STRING, false);
24795  if (vlkeys_[VL_STRING].count(key1key) != 1) {
24796  AppendVLKey(keysds1key, VL_STRING, key1key);
24797  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
24798  }
24799  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
24800  unsigned int count1val=0;
24801  std::map<std::string, double>::iterator it1val=it0->second.begin();
24802  std::map<std::string, double> fixed_val1val;
24803  unsigned int pad_count1val=0;
24804  for(;it1val!=it0->second.end();++it1val){
24805  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
24806  fixed_val1val[child2valkey] = it1val->second;
24807  ++pad_count1val;
24808 
24809  }
24810  hasher_.Clear();
24811  hasher_.Update(fixed_val1val);
24812  Digest key1val = hasher_.digest();
24813  hid_t keysds1val = VLDataset(VL_MAP_STRING_DOUBLE, true);
24814  hid_t valsds1val = VLDataset(VL_MAP_STRING_DOUBLE, false);
24815  if (vlkeys_[VL_MAP_STRING_DOUBLE].count(key1val) != 1) {
24816  hvl_t buf1val = VLValToBuf(fixed_val1val);
24817  AppendVLKey(keysds1val, VL_MAP_STRING_DOUBLE, key1val);
24818  InsertVLVal(valsds1val, VL_MAP_STRING_DOUBLE, key1val, buf1val);
24819  }
24820  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
24821  ++count0;
24822 
24823  }
24824  if(total_item_size0*length0<column){
24825  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24826 
24827  }
24828 }
24829 template<>
24830 void Hdf5Back::WriteToBuf<MAP_VL_STRING_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24831  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24832  size_t item_size0=((CYCLUS_SHA1_SIZE+((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]))*shape[0]);
24833  size_t length0=shape[0];
24834  size_t item_size1key=CYCLUS_SHA1_SIZE;
24835  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
24836  size_t length1val=shape[2];
24837  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
24838  size_t item_size2valval=sizeof(double);
24839  size_t total_item_size1val=item_size2valkey+item_size2valval;
24840  size_t total_item_size0=item_size1key+item_size1val;
24841  if(total_item_size0*val0.size()>column){
24842  std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24843  std::advance(eraseit, column/total_item_size0);
24844  val0.erase(eraseit,val0.end());
24845 
24846  }
24847  unsigned int count0=0;
24848  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24849  for(;it0!=val0.end();++it0){
24850  hasher_.Clear();
24851  hasher_.Update(it0->first);
24852  Digest key1key = hasher_.digest();
24853  hid_t keysds1key = VLDataset(VL_STRING, true);
24854  hid_t valsds1key = VLDataset(VL_STRING, false);
24855  if (vlkeys_[VL_STRING].count(key1key) != 1) {
24856  AppendVLKey(keysds1key, VL_STRING, key1key);
24857  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
24858  }
24859  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
24860  unsigned int count1val=0;
24861  std::map<std::string, double>::iterator it1val=it0->second.begin();
24862  for(;it1val!=it0->second.end();++it1val){
24863  hasher_.Clear();
24864  hasher_.Update(it1val->first);
24865  Digest key2valkey = hasher_.digest();
24866  hid_t keysds2valkey = VLDataset(VL_STRING, true);
24867  hid_t valsds2valkey = VLDataset(VL_STRING, false);
24868  if (vlkeys_[VL_STRING].count(key2valkey) != 1) {
24869  AppendVLKey(keysds2valkey, VL_STRING, key2valkey);
24870  InsertVLVal(valsds2valkey, VL_STRING, key2valkey, it1val->first);
24871  }
24872  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0, key2valkey.val, CYCLUS_SHA1_SIZE);
24873  memcpy(buf+(count0*total_item_size0)+0+item_size1key+(count1val*total_item_size1val)+0+item_size2valkey, &(it1val->second), item_size2valval);
24874  ++count1val;
24875 
24876  }
24877  memset(buf+(count0*total_item_size0)+0+item_size1key+total_item_size1val*count1val, 0, total_item_size1val*(length1val-count1val));
24878  ++count0;
24879 
24880  }
24881  if(total_item_size0*length0<column){
24882  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24883 
24884  }
24885 }
24886 template<>
24887 void Hdf5Back::WriteToBuf<MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24888  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24889  size_t item_size0=((CYCLUS_SHA1_SIZE+(CYCLUS_SHA1_SIZE))*shape[0]);
24890  size_t length0=shape[0];
24891  size_t item_size1key=CYCLUS_SHA1_SIZE;
24892  size_t item_size1val=(CYCLUS_SHA1_SIZE);
24893  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
24894  size_t item_size2valval=sizeof(double);
24895  size_t total_item_size1val=item_size2valkey+item_size2valval;
24896  size_t total_item_size0=item_size1key+item_size1val;
24897  if(total_item_size0*val0.size()>column){
24898  std::map<std::string, std::map<std::string, double>>::iterator eraseit=val0.begin();
24899  std::advance(eraseit, column/total_item_size0);
24900  val0.erase(eraseit,val0.end());
24901 
24902  }
24903  unsigned int count0=0;
24904  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24905  for(;it0!=val0.end();++it0){
24906  hasher_.Clear();
24907  hasher_.Update(it0->first);
24908  Digest key1key = hasher_.digest();
24909  hid_t keysds1key = VLDataset(VL_STRING, true);
24910  hid_t valsds1key = VLDataset(VL_STRING, false);
24911  if (vlkeys_[VL_STRING].count(key1key) != 1) {
24912  AppendVLKey(keysds1key, VL_STRING, key1key);
24913  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
24914  }
24915  memcpy(buf+(count0*total_item_size0)+0, key1key.val, CYCLUS_SHA1_SIZE);
24916  hasher_.Clear();
24917  hasher_.Update(it0->second);
24918  Digest key1val = hasher_.digest();
24919  hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
24920  hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
24921  if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
24922  hvl_t buf1val = VLValToBuf(it0->second);
24923  AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
24924  InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
24925  }
24926  memcpy(buf+(count0*total_item_size0)+0+item_size1key, key1val.val, CYCLUS_SHA1_SIZE);
24927  ++count0;
24928 
24929  }
24930  if(total_item_size0*length0<column){
24931  memset(buf+total_item_size0*count0, 0, total_item_size0*(length0-count0));
24932 
24933  }
24934 }
24935 template<>
24936 void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24937  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24938  size_t item_size0=(CYCLUS_SHA1_SIZE);
24939  size_t item_size1key=shape[1];
24940  size_t valuelen1key;
24941  size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
24942  size_t length1val=shape[2];
24943  size_t item_size2valkey=shape[3];
24944  size_t valuelen2valkey;
24945  size_t item_size2valval=sizeof(double);
24946  size_t total_item_size1val=item_size2valkey+item_size2valval;
24947  size_t total_item_size0=item_size1key+item_size1val;
24948  unsigned int count0=0;
24949  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24950  std::map<std::string, std::map<std::string, double>> fixed_val0;
24951  unsigned int pad_count0=0;
24952  for(;it0!=val0.end();++it0){
24953  std::string child1key=std::string(it0->first,0,item_size1key);
24954  std::map<std::string, double> child1val;
24955  unsigned int pad_count1val=0;
24956  std::map<std::string, double>::iterator it1val=it0->second.begin();
24957  for(;it1val!=it0->second.end();++it1val){
24958  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
24959  child1val[child2valkey] = it1val->second;
24960  ++pad_count1val;
24961 
24962  }
24963  fixed_val0[child1key] = child1val;
24964  ++pad_count0;
24965 
24966  }
24967  hasher_.Clear();
24968  hasher_.Update(fixed_val0);
24969  Digest key0 = hasher_.digest();
24970  hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_STRING_DOUBLE, true);
24971  hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_STRING_DOUBLE, false);
24972  if (vlkeys_[VL_MAP_STRING_MAP_STRING_DOUBLE].count(key0) != 1) {
24973  hvl_t buf0 = VLValToBuf(fixed_val0);
24974  AppendVLKey(keysds0, VL_MAP_STRING_MAP_STRING_DOUBLE, key0);
24975  InsertVLVal(valsds0, VL_MAP_STRING_MAP_STRING_DOUBLE, key0, buf0);
24976  }
24977  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
24978 }
24979 template<>
24980 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
24981  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
24982  size_t item_size0=(CYCLUS_SHA1_SIZE);
24983  size_t item_size1key=CYCLUS_SHA1_SIZE;
24984  size_t item_size1val=((shape[3]+sizeof(double))*shape[2]);
24985  size_t length1val=shape[2];
24986  size_t item_size2valkey=shape[3];
24987  size_t valuelen2valkey;
24988  size_t item_size2valval=sizeof(double);
24989  size_t total_item_size1val=item_size2valkey+item_size2valval;
24990  size_t total_item_size0=item_size1key+item_size1val;
24991  unsigned int count0=0;
24992  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
24993  std::map<std::string, std::map<std::string, double>> fixed_val0;
24994  unsigned int pad_count0=0;
24995  for(;it0!=val0.end();++it0){
24996  std::map<std::string, double> child1val;
24997  unsigned int pad_count1val=0;
24998  std::map<std::string, double>::iterator it1val=it0->second.begin();
24999  for(;it1val!=it0->second.end();++it1val){
25000  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
25001  child1val[child2valkey] = it1val->second;
25002  ++pad_count1val;
25003 
25004  }
25005  fixed_val0[it0->first] = child1val;
25006  ++pad_count0;
25007 
25008  }
25009  hasher_.Clear();
25010  hasher_.Update(fixed_val0);
25011  Digest key0 = hasher_.digest();
25012  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_STRING_DOUBLE, true);
25013  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_STRING_DOUBLE, false);
25014  if (vlkeys_[VL_MAP_VL_STRING_MAP_STRING_DOUBLE].count(key0) != 1) {
25015  hvl_t buf0 = VLValToBuf(fixed_val0);
25016  AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_STRING_DOUBLE, key0);
25017  InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_STRING_DOUBLE, key0, buf0);
25018  }
25019  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
25020 }
25021 template<>
25022 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
25023  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25024  size_t item_size0=(CYCLUS_SHA1_SIZE);
25025  size_t item_size1key=shape[1];
25026  size_t valuelen1key;
25027  size_t item_size1val=(CYCLUS_SHA1_SIZE);
25028  size_t item_size2valkey=shape[3];
25029  size_t valuelen2valkey;
25030  size_t item_size2valval=sizeof(double);
25031  size_t total_item_size1val=item_size2valkey+item_size2valval;
25032  size_t total_item_size0=item_size1key+item_size1val;
25033  unsigned int count0=0;
25034  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25035  std::map<std::string, std::map<std::string, double>> fixed_val0;
25036  unsigned int pad_count0=0;
25037  for(;it0!=val0.end();++it0){
25038  std::string child1key=std::string(it0->first,0,item_size1key);
25039  std::map<std::string, double> child1val;
25040  unsigned int pad_count1val=0;
25041  std::map<std::string, double>::iterator it1val=it0->second.begin();
25042  for(;it1val!=it0->second.end();++it1val){
25043  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
25044  child1val[child2valkey] = it1val->second;
25045  ++pad_count1val;
25046 
25047  }
25048  fixed_val0[child1key] = child1val;
25049  ++pad_count0;
25050 
25051  }
25052  hasher_.Clear();
25053  hasher_.Update(fixed_val0);
25054  Digest key0 = hasher_.digest();
25055  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_STRING_DOUBLE, true);
25056  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_STRING_DOUBLE, false);
25057  if (vlkeys_[VL_MAP_STRING_VL_MAP_STRING_DOUBLE].count(key0) != 1) {
25058  hvl_t buf0 = VLValToBuf(fixed_val0);
25059  AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_STRING_DOUBLE, key0);
25060  InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_STRING_DOUBLE, key0, buf0);
25061  }
25062  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
25063 }
25064 template<>
25065 void Hdf5Back::WriteToBuf<VL_MAP_STRING_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
25066  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25067  size_t item_size0=(CYCLUS_SHA1_SIZE);
25068  size_t item_size1key=shape[1];
25069  size_t valuelen1key;
25070  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
25071  size_t length1val=shape[2];
25072  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
25073  size_t item_size2valval=sizeof(double);
25074  size_t total_item_size1val=item_size2valkey+item_size2valval;
25075  size_t total_item_size0=item_size1key+item_size1val;
25076  unsigned int count0=0;
25077  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25078  std::map<std::string, std::map<std::string, double>> fixed_val0;
25079  unsigned int pad_count0=0;
25080  for(;it0!=val0.end();++it0){
25081  std::string child1key=std::string(it0->first,0,item_size1key);
25082  std::map<std::string, double> child1val;
25083  unsigned int pad_count1val=0;
25084  std::map<std::string, double>::iterator it1val=it0->second.begin();
25085  for(;it1val!=it0->second.end();++it1val){
25086  child1val[it1val->first] = it1val->second;
25087  ++pad_count1val;
25088 
25089  }
25090  fixed_val0[child1key] = child1val;
25091  ++pad_count0;
25092 
25093  }
25094  hasher_.Clear();
25095  hasher_.Update(fixed_val0);
25096  Digest key0 = hasher_.digest();
25097  hid_t keysds0 = VLDataset(VL_MAP_STRING_MAP_VL_STRING_DOUBLE, true);
25098  hid_t valsds0 = VLDataset(VL_MAP_STRING_MAP_VL_STRING_DOUBLE, false);
25099  if (vlkeys_[VL_MAP_STRING_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
25100  hvl_t buf0 = VLValToBuf(fixed_val0);
25101  AppendVLKey(keysds0, VL_MAP_STRING_MAP_VL_STRING_DOUBLE, key0);
25102  InsertVLVal(valsds0, VL_MAP_STRING_MAP_VL_STRING_DOUBLE, key0, buf0);
25103  }
25104  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
25105 }
25106 template<>
25107 void Hdf5Back::WriteToBuf<VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
25108  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25109  size_t item_size0=(CYCLUS_SHA1_SIZE);
25110  size_t item_size1key=shape[1];
25111  size_t valuelen1key;
25112  size_t item_size1val=(CYCLUS_SHA1_SIZE);
25113  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
25114  size_t item_size2valval=sizeof(double);
25115  size_t total_item_size1val=item_size2valkey+item_size2valval;
25116  size_t total_item_size0=item_size1key+item_size1val;
25117  unsigned int count0=0;
25118  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25119  std::map<std::string, std::map<std::string, double>> fixed_val0;
25120  unsigned int pad_count0=0;
25121  for(;it0!=val0.end();++it0){
25122  std::string child1key=std::string(it0->first,0,item_size1key);
25123  fixed_val0[child1key] = it0->second;
25124  ++pad_count0;
25125 
25126  }
25127  hasher_.Clear();
25128  hasher_.Update(fixed_val0);
25129  Digest key0 = hasher_.digest();
25130  hid_t keysds0 = VLDataset(VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE, true);
25131  hid_t valsds0 = VLDataset(VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE, false);
25132  if (vlkeys_[VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
25133  hvl_t buf0 = VLValToBuf(fixed_val0);
25134  AppendVLKey(keysds0, VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE, key0);
25135  InsertVLVal(valsds0, VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE, key0, buf0);
25136  }
25137  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
25138 }
25139 template<>
25140 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
25141  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25142  size_t item_size0=(CYCLUS_SHA1_SIZE);
25143  size_t item_size1key=CYCLUS_SHA1_SIZE;
25144  size_t item_size1val=((CYCLUS_SHA1_SIZE+sizeof(double))*shape[2]);
25145  size_t length1val=shape[2];
25146  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
25147  size_t item_size2valval=sizeof(double);
25148  size_t total_item_size1val=item_size2valkey+item_size2valval;
25149  size_t total_item_size0=item_size1key+item_size1val;
25150  unsigned int count0=0;
25151  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25152  std::map<std::string, std::map<std::string, double>> fixed_val0;
25153  unsigned int pad_count0=0;
25154  for(;it0!=val0.end();++it0){
25155  std::map<std::string, double> child1val;
25156  unsigned int pad_count1val=0;
25157  std::map<std::string, double>::iterator it1val=it0->second.begin();
25158  for(;it1val!=it0->second.end();++it1val){
25159  child1val[it1val->first] = it1val->second;
25160  ++pad_count1val;
25161 
25162  }
25163  fixed_val0[it0->first] = child1val;
25164  ++pad_count0;
25165 
25166  }
25167  hasher_.Clear();
25168  hasher_.Update(fixed_val0);
25169  Digest key0 = hasher_.digest();
25170  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE, true);
25171  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE, false);
25172  if (vlkeys_[VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
25173  hvl_t buf0 = VLValToBuf(fixed_val0);
25174  AppendVLKey(keysds0, VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE, key0);
25175  InsertVLVal(valsds0, VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE, key0, buf0);
25176  }
25177  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
25178 }
25179 template<>
25180 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
25181  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25182  size_t item_size0=(CYCLUS_SHA1_SIZE);
25183  size_t item_size1key=CYCLUS_SHA1_SIZE;
25184  size_t item_size1val=(CYCLUS_SHA1_SIZE);
25185  size_t item_size2valkey=shape[3];
25186  size_t valuelen2valkey;
25187  size_t item_size2valval=sizeof(double);
25188  size_t total_item_size1val=item_size2valkey+item_size2valval;
25189  size_t total_item_size0=item_size1key+item_size1val;
25190  unsigned int count0=0;
25191  std::map<std::string, std::map<std::string, double>>::iterator it0=val0.begin();
25192  std::map<std::string, std::map<std::string, double>> fixed_val0;
25193  unsigned int pad_count0=0;
25194  for(;it0!=val0.end();++it0){
25195  std::map<std::string, double> child1val;
25196  unsigned int pad_count1val=0;
25197  std::map<std::string, double>::iterator it1val=it0->second.begin();
25198  for(;it1val!=it0->second.end();++it1val){
25199  std::string child2valkey=std::string(it1val->first,0,item_size2valkey);
25200  child1val[child2valkey] = it1val->second;
25201  ++pad_count1val;
25202 
25203  }
25204  fixed_val0[it0->first] = child1val;
25205  ++pad_count0;
25206 
25207  }
25208  hasher_.Clear();
25209  hasher_.Update(fixed_val0);
25210  Digest key0 = hasher_.digest();
25211  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE, true);
25212  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE, false);
25213  if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE].count(key0) != 1) {
25214  hvl_t buf0 = VLValToBuf(fixed_val0);
25215  AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE, key0);
25216  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE, key0, buf0);
25217  }
25218  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
25219 }
25220 template<>
25221 void Hdf5Back::WriteToBuf<VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE>(char* buf, std::vector<int>& shape, const boost::spirit::hold_any* a, size_t column) {
25222  std::map<std::string, std::map<std::string, double>> val0=a->cast<std::map<std::string, std::map<std::string, double>>>();
25223  size_t item_size0=(CYCLUS_SHA1_SIZE);
25224  size_t item_size1key=CYCLUS_SHA1_SIZE;
25225  size_t item_size1val=(CYCLUS_SHA1_SIZE);
25226  size_t item_size2valkey=CYCLUS_SHA1_SIZE;
25227  size_t item_size2valval=sizeof(double);
25228  size_t total_item_size1val=item_size2valkey+item_size2valval;
25229  size_t total_item_size0=item_size1key+item_size1val;
25230  hasher_.Clear();
25231  hasher_.Update(val0);
25232  Digest key0 = hasher_.digest();
25233  hid_t keysds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE, true);
25234  hid_t valsds0 = VLDataset(VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE, false);
25235  if (vlkeys_[VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE].count(key0) != 1) {
25236  hvl_t buf0 = VLValToBuf(val0);
25237  AppendVLKey(keysds0, VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE, key0);
25238  InsertVLVal(valsds0, VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE, key0, buf0);
25239  }
25240  memcpy(buf, key0.val, CYCLUS_SHA1_SIZE);
25241 }
25242 
25243 
25244 
25245 void Hdf5Back::FillBuf(std::string title, char* buf, DatumList& group,
25246  size_t* sizes, size_t rowsize) {
25247  using std::min;
25248  using std::string;
25249  using std::vector;
25250  using std::set;
25251  using std::list;
25252  using std::pair;
25253  using std::map;
25254  Datum::Vals vals;
25255  Datum::Shape shape;
25256  Datum::Shapes shapes;
25257  Datum::Vals header = group.front()->vals();
25258  int ncols = header.size();
25259  DbTypes* dbtypes = schemas_[title];
25260 
25261  size_t offset = 0;
25262  const void* val;
25263  size_t fieldlen;
25264  size_t valuelen;
25265  DatumList::iterator it;
25266  for (it = group.begin(); it != group.end(); ++it) {
25267  vals = (*it)->vals();
25268  shapes = (*it)->shapes();
25269  for (int col = 0; col < ncols; ++col) {
25270  const boost::spirit::hold_any* a = &(vals[col].second);
25271  switch (dbtypes[col]) {
25272  case BOOL: {
25273  WriteToBuf<BOOL>(buf+offset, shapes[col], a, sizes[col]);
25274  break;
25275 
25276  }
25277  case INT: {
25278  WriteToBuf<INT>(buf+offset, shapes[col], a, sizes[col]);
25279  break;
25280 
25281  }
25282  case FLOAT: {
25283  WriteToBuf<FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25284  break;
25285 
25286  }
25287  case DOUBLE: {
25288  WriteToBuf<DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25289  break;
25290 
25291  }
25292  case STRING: {
25293  WriteToBuf<STRING>(buf+offset, shapes[col], a, sizes[col]);
25294  break;
25295 
25296  }
25297  case VL_STRING: {
25298  WriteToBuf<VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25299  break;
25300 
25301  }
25302  case BLOB: {
25303  WriteToBuf<BLOB>(buf+offset, shapes[col], a, sizes[col]);
25304  break;
25305 
25306  }
25307  case UUID: {
25308  WriteToBuf<UUID>(buf+offset, shapes[col], a, sizes[col]);
25309  break;
25310 
25311  }
25312  case VECTOR_INT: {
25313  WriteToBuf<VECTOR_INT>(buf+offset, shapes[col], a, sizes[col]);
25314  break;
25315 
25316  }
25317  case VL_VECTOR_INT: {
25318  WriteToBuf<VL_VECTOR_INT>(buf+offset, shapes[col], a, sizes[col]);
25319  break;
25320 
25321  }
25322  case VECTOR_FLOAT: {
25323  WriteToBuf<VECTOR_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25324  break;
25325 
25326  }
25327  case VL_VECTOR_FLOAT: {
25328  WriteToBuf<VL_VECTOR_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25329  break;
25330 
25331  }
25332  case VECTOR_DOUBLE: {
25333  WriteToBuf<VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25334  break;
25335 
25336  }
25337  case VL_VECTOR_DOUBLE: {
25338  WriteToBuf<VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25339  break;
25340 
25341  }
25342  case VECTOR_STRING: {
25343  WriteToBuf<VECTOR_STRING>(buf+offset, shapes[col], a, sizes[col]);
25344  break;
25345 
25346  }
25347  case VL_VECTOR_STRING: {
25348  WriteToBuf<VL_VECTOR_STRING>(buf+offset, shapes[col], a, sizes[col]);
25349  break;
25350 
25351  }
25352  case VECTOR_VL_STRING: {
25353  WriteToBuf<VECTOR_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25354  break;
25355 
25356  }
25357  case VL_VECTOR_VL_STRING: {
25358  WriteToBuf<VL_VECTOR_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25359  break;
25360 
25361  }
25362  case VECTOR_BLOB: {
25363  WriteToBuf<VECTOR_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25364  break;
25365 
25366  }
25367  case VL_VECTOR_BLOB: {
25368  WriteToBuf<VL_VECTOR_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25369  break;
25370 
25371  }
25372  case VECTOR_UUID: {
25373  WriteToBuf<VECTOR_UUID>(buf+offset, shapes[col], a, sizes[col]);
25374  break;
25375 
25376  }
25377  case VL_VECTOR_UUID: {
25378  WriteToBuf<VL_VECTOR_UUID>(buf+offset, shapes[col], a, sizes[col]);
25379  break;
25380 
25381  }
25382  case SET_INT: {
25383  WriteToBuf<SET_INT>(buf+offset, shapes[col], a, sizes[col]);
25384  break;
25385 
25386  }
25387  case VL_SET_INT: {
25388  WriteToBuf<VL_SET_INT>(buf+offset, shapes[col], a, sizes[col]);
25389  break;
25390 
25391  }
25392  case SET_FLOAT: {
25393  WriteToBuf<SET_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25394  break;
25395 
25396  }
25397  case VL_SET_FLOAT: {
25398  WriteToBuf<VL_SET_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25399  break;
25400 
25401  }
25402  case SET_DOUBLE: {
25403  WriteToBuf<SET_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25404  break;
25405 
25406  }
25407  case VL_SET_DOUBLE: {
25408  WriteToBuf<VL_SET_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25409  break;
25410 
25411  }
25412  case SET_STRING: {
25413  WriteToBuf<SET_STRING>(buf+offset, shapes[col], a, sizes[col]);
25414  break;
25415 
25416  }
25417  case VL_SET_STRING: {
25418  WriteToBuf<VL_SET_STRING>(buf+offset, shapes[col], a, sizes[col]);
25419  break;
25420 
25421  }
25422  case SET_VL_STRING: {
25423  WriteToBuf<SET_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25424  break;
25425 
25426  }
25427  case VL_SET_VL_STRING: {
25428  WriteToBuf<VL_SET_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25429  break;
25430 
25431  }
25432  case SET_BLOB: {
25433  WriteToBuf<SET_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25434  break;
25435 
25436  }
25437  case VL_SET_BLOB: {
25438  WriteToBuf<VL_SET_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25439  break;
25440 
25441  }
25442  case SET_UUID: {
25443  WriteToBuf<SET_UUID>(buf+offset, shapes[col], a, sizes[col]);
25444  break;
25445 
25446  }
25447  case VL_SET_UUID: {
25448  WriteToBuf<VL_SET_UUID>(buf+offset, shapes[col], a, sizes[col]);
25449  break;
25450 
25451  }
25452  case LIST_BOOL: {
25453  WriteToBuf<LIST_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25454  break;
25455 
25456  }
25457  case VL_LIST_BOOL: {
25458  WriteToBuf<VL_LIST_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25459  break;
25460 
25461  }
25462  case LIST_INT: {
25463  WriteToBuf<LIST_INT>(buf+offset, shapes[col], a, sizes[col]);
25464  break;
25465 
25466  }
25467  case VL_LIST_INT: {
25468  WriteToBuf<VL_LIST_INT>(buf+offset, shapes[col], a, sizes[col]);
25469  break;
25470 
25471  }
25472  case LIST_FLOAT: {
25473  WriteToBuf<LIST_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25474  break;
25475 
25476  }
25477  case VL_LIST_FLOAT: {
25478  WriteToBuf<VL_LIST_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25479  break;
25480 
25481  }
25482  case LIST_DOUBLE: {
25483  WriteToBuf<LIST_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25484  break;
25485 
25486  }
25487  case VL_LIST_DOUBLE: {
25488  WriteToBuf<VL_LIST_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25489  break;
25490 
25491  }
25492  case LIST_STRING: {
25493  WriteToBuf<LIST_STRING>(buf+offset, shapes[col], a, sizes[col]);
25494  break;
25495 
25496  }
25497  case VL_LIST_STRING: {
25498  WriteToBuf<VL_LIST_STRING>(buf+offset, shapes[col], a, sizes[col]);
25499  break;
25500 
25501  }
25502  case LIST_VL_STRING: {
25503  WriteToBuf<LIST_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25504  break;
25505 
25506  }
25507  case VL_LIST_VL_STRING: {
25508  WriteToBuf<VL_LIST_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25509  break;
25510 
25511  }
25512  case LIST_BLOB: {
25513  WriteToBuf<LIST_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25514  break;
25515 
25516  }
25517  case VL_LIST_BLOB: {
25518  WriteToBuf<VL_LIST_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25519  break;
25520 
25521  }
25522  case LIST_UUID: {
25523  WriteToBuf<LIST_UUID>(buf+offset, shapes[col], a, sizes[col]);
25524  break;
25525 
25526  }
25527  case VL_LIST_UUID: {
25528  WriteToBuf<VL_LIST_UUID>(buf+offset, shapes[col], a, sizes[col]);
25529  break;
25530 
25531  }
25532  case PAIR_INT_BOOL: {
25533  WriteToBuf<PAIR_INT_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25534  break;
25535 
25536  }
25537  case PAIR_INT_INT: {
25538  WriteToBuf<PAIR_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
25539  break;
25540 
25541  }
25542  case PAIR_INT_FLOAT: {
25543  WriteToBuf<PAIR_INT_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25544  break;
25545 
25546  }
25547  case PAIR_INT_DOUBLE: {
25548  WriteToBuf<PAIR_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25549  break;
25550 
25551  }
25552  case PAIR_INT_STRING: {
25553  WriteToBuf<PAIR_INT_STRING>(buf+offset, shapes[col], a, sizes[col]);
25554  break;
25555 
25556  }
25557  case PAIR_INT_VL_STRING: {
25558  WriteToBuf<PAIR_INT_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25559  break;
25560 
25561  }
25562  case PAIR_INT_BLOB: {
25563  WriteToBuf<PAIR_INT_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25564  break;
25565 
25566  }
25567  case PAIR_INT_UUID: {
25568  WriteToBuf<PAIR_INT_UUID>(buf+offset, shapes[col], a, sizes[col]);
25569  break;
25570 
25571  }
25572  case PAIR_STRING_BOOL: {
25573  WriteToBuf<PAIR_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25574  break;
25575 
25576  }
25577  case PAIR_STRING_INT: {
25578  WriteToBuf<PAIR_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25579  break;
25580 
25581  }
25582  case PAIR_STRING_FLOAT: {
25583  WriteToBuf<PAIR_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25584  break;
25585 
25586  }
25587  case PAIR_STRING_DOUBLE: {
25588  WriteToBuf<PAIR_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25589  break;
25590 
25591  }
25592  case PAIR_STRING_STRING: {
25593  WriteToBuf<PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25594  break;
25595 
25596  }
25597  case PAIR_STRING_VL_STRING: {
25598  WriteToBuf<PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25599  break;
25600 
25601  }
25602  case PAIR_STRING_BLOB: {
25603  WriteToBuf<PAIR_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25604  break;
25605 
25606  }
25607  case PAIR_STRING_UUID: {
25608  WriteToBuf<PAIR_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25609  break;
25610 
25611  }
25612  case PAIR_VL_STRING_BOOL: {
25613  WriteToBuf<PAIR_VL_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25614  break;
25615 
25616  }
25617  case PAIR_VL_STRING_INT: {
25618  WriteToBuf<PAIR_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25619  break;
25620 
25621  }
25622  case PAIR_VL_STRING_FLOAT: {
25623  WriteToBuf<PAIR_VL_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25624  break;
25625 
25626  }
25627  case PAIR_VL_STRING_DOUBLE: {
25628  WriteToBuf<PAIR_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25629  break;
25630 
25631  }
25632  case PAIR_VL_STRING_STRING: {
25633  WriteToBuf<PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25634  break;
25635 
25636  }
25637  case PAIR_VL_STRING_VL_STRING: {
25638  WriteToBuf<PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25639  break;
25640 
25641  }
25642  case PAIR_VL_STRING_BLOB: {
25643  WriteToBuf<PAIR_VL_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25644  break;
25645 
25646  }
25647  case PAIR_VL_STRING_UUID: {
25648  WriteToBuf<PAIR_VL_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25649  break;
25650 
25651  }
25652  case MAP_INT_BOOL: {
25653  WriteToBuf<MAP_INT_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25654  break;
25655 
25656  }
25657  case VL_MAP_INT_BOOL: {
25658  WriteToBuf<VL_MAP_INT_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25659  break;
25660 
25661  }
25662  case MAP_INT_INT: {
25663  WriteToBuf<MAP_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
25664  break;
25665 
25666  }
25667  case VL_MAP_INT_INT: {
25668  WriteToBuf<VL_MAP_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
25669  break;
25670 
25671  }
25672  case MAP_INT_FLOAT: {
25673  WriteToBuf<MAP_INT_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25674  break;
25675 
25676  }
25677  case VL_MAP_INT_FLOAT: {
25678  WriteToBuf<VL_MAP_INT_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25679  break;
25680 
25681  }
25682  case MAP_INT_DOUBLE: {
25683  WriteToBuf<MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25684  break;
25685 
25686  }
25687  case VL_MAP_INT_DOUBLE: {
25688  WriteToBuf<VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25689  break;
25690 
25691  }
25692  case MAP_INT_STRING: {
25693  WriteToBuf<MAP_INT_STRING>(buf+offset, shapes[col], a, sizes[col]);
25694  break;
25695 
25696  }
25697  case VL_MAP_INT_STRING: {
25698  WriteToBuf<VL_MAP_INT_STRING>(buf+offset, shapes[col], a, sizes[col]);
25699  break;
25700 
25701  }
25702  case MAP_INT_VL_STRING: {
25703  WriteToBuf<MAP_INT_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25704  break;
25705 
25706  }
25707  case VL_MAP_INT_VL_STRING: {
25708  WriteToBuf<VL_MAP_INT_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25709  break;
25710 
25711  }
25712  case MAP_INT_BLOB: {
25713  WriteToBuf<MAP_INT_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25714  break;
25715 
25716  }
25717  case VL_MAP_INT_BLOB: {
25718  WriteToBuf<VL_MAP_INT_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25719  break;
25720 
25721  }
25722  case MAP_INT_UUID: {
25723  WriteToBuf<MAP_INT_UUID>(buf+offset, shapes[col], a, sizes[col]);
25724  break;
25725 
25726  }
25727  case VL_MAP_INT_UUID: {
25728  WriteToBuf<VL_MAP_INT_UUID>(buf+offset, shapes[col], a, sizes[col]);
25729  break;
25730 
25731  }
25732  case MAP_STRING_BOOL: {
25733  WriteToBuf<MAP_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25734  break;
25735 
25736  }
25737  case VL_MAP_STRING_BOOL: {
25738  WriteToBuf<VL_MAP_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25739  break;
25740 
25741  }
25742  case MAP_STRING_INT: {
25743  WriteToBuf<MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25744  break;
25745 
25746  }
25747  case VL_MAP_STRING_INT: {
25748  WriteToBuf<VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25749  break;
25750 
25751  }
25752  case MAP_STRING_FLOAT: {
25753  WriteToBuf<MAP_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25754  break;
25755 
25756  }
25757  case VL_MAP_STRING_FLOAT: {
25758  WriteToBuf<VL_MAP_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25759  break;
25760 
25761  }
25762  case MAP_STRING_DOUBLE: {
25763  WriteToBuf<MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25764  break;
25765 
25766  }
25767  case VL_MAP_STRING_DOUBLE: {
25768  WriteToBuf<VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25769  break;
25770 
25771  }
25772  case MAP_STRING_STRING: {
25773  WriteToBuf<MAP_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25774  break;
25775 
25776  }
25777  case VL_MAP_STRING_STRING: {
25778  WriteToBuf<VL_MAP_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25779  break;
25780 
25781  }
25782  case MAP_STRING_VL_STRING: {
25783  WriteToBuf<MAP_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25784  break;
25785 
25786  }
25787  case VL_MAP_STRING_VL_STRING: {
25788  WriteToBuf<VL_MAP_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25789  break;
25790 
25791  }
25792  case MAP_STRING_BLOB: {
25793  WriteToBuf<MAP_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25794  break;
25795 
25796  }
25797  case VL_MAP_STRING_BLOB: {
25798  WriteToBuf<VL_MAP_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25799  break;
25800 
25801  }
25802  case MAP_STRING_UUID: {
25803  WriteToBuf<MAP_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25804  break;
25805 
25806  }
25807  case VL_MAP_STRING_UUID: {
25808  WriteToBuf<VL_MAP_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25809  break;
25810 
25811  }
25812  case MAP_VL_STRING_BOOL: {
25813  WriteToBuf<MAP_VL_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25814  break;
25815 
25816  }
25817  case VL_MAP_VL_STRING_BOOL: {
25818  WriteToBuf<VL_MAP_VL_STRING_BOOL>(buf+offset, shapes[col], a, sizes[col]);
25819  break;
25820 
25821  }
25822  case MAP_VL_STRING_INT: {
25823  WriteToBuf<MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25824  break;
25825 
25826  }
25827  case VL_MAP_VL_STRING_INT: {
25828  WriteToBuf<VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
25829  break;
25830 
25831  }
25832  case MAP_VL_STRING_FLOAT: {
25833  WriteToBuf<MAP_VL_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25834  break;
25835 
25836  }
25837  case VL_MAP_VL_STRING_FLOAT: {
25838  WriteToBuf<VL_MAP_VL_STRING_FLOAT>(buf+offset, shapes[col], a, sizes[col]);
25839  break;
25840 
25841  }
25842  case MAP_VL_STRING_DOUBLE: {
25843  WriteToBuf<MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25844  break;
25845 
25846  }
25847  case VL_MAP_VL_STRING_DOUBLE: {
25848  WriteToBuf<VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25849  break;
25850 
25851  }
25852  case MAP_VL_STRING_STRING: {
25853  WriteToBuf<MAP_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25854  break;
25855 
25856  }
25857  case VL_MAP_VL_STRING_STRING: {
25858  WriteToBuf<VL_MAP_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
25859  break;
25860 
25861  }
25862  case MAP_VL_STRING_VL_STRING: {
25863  WriteToBuf<MAP_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25864  break;
25865 
25866  }
25868  WriteToBuf<VL_MAP_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
25869  break;
25870 
25871  }
25872  case MAP_VL_STRING_BLOB: {
25873  WriteToBuf<MAP_VL_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25874  break;
25875 
25876  }
25877  case VL_MAP_VL_STRING_BLOB: {
25878  WriteToBuf<VL_MAP_VL_STRING_BLOB>(buf+offset, shapes[col], a, sizes[col]);
25879  break;
25880 
25881  }
25882  case MAP_VL_STRING_UUID: {
25883  WriteToBuf<MAP_VL_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25884  break;
25885 
25886  }
25887  case VL_MAP_VL_STRING_UUID: {
25888  WriteToBuf<VL_MAP_VL_STRING_UUID>(buf+offset, shapes[col], a, sizes[col]);
25889  break;
25890 
25891  }
25893  WriteToBuf<MAP_PAIR_INT_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25894  break;
25895 
25896  }
25898  WriteToBuf<VL_MAP_PAIR_INT_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25899  break;
25900 
25901  }
25903  WriteToBuf<MAP_PAIR_INT_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25904  break;
25905 
25906  }
25908  WriteToBuf<VL_MAP_PAIR_INT_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25909  break;
25910 
25911  }
25912  case MAP_STRING_VECTOR_DOUBLE: {
25913  WriteToBuf<MAP_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25914  break;
25915 
25916  }
25918  WriteToBuf<MAP_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25919  break;
25920 
25921  }
25923  WriteToBuf<VL_MAP_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25924  break;
25925 
25926  }
25928  WriteToBuf<MAP_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25929  break;
25930 
25931  }
25933  WriteToBuf<MAP_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25934  break;
25935 
25936  }
25938  WriteToBuf<VL_MAP_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25939  break;
25940 
25941  }
25943  WriteToBuf<VL_MAP_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25944  break;
25945 
25946  }
25948  WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25949  break;
25950 
25951  }
25953  WriteToBuf<MAP_STRING_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25954  break;
25955 
25956  }
25958  WriteToBuf<MAP_STRING_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25959  break;
25960 
25961  }
25963  WriteToBuf<VL_MAP_STRING_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25964  break;
25965 
25966  }
25968  WriteToBuf<MAP_VL_STRING_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25969  break;
25970 
25971  }
25973  WriteToBuf<MAP_VL_STRING_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25974  break;
25975 
25976  }
25978  WriteToBuf<VL_MAP_STRING_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25979  break;
25980 
25981  }
25983  WriteToBuf<VL_MAP_VL_STRING_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25984  break;
25985 
25986  }
25988  WriteToBuf<VL_MAP_VL_STRING_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25989  break;
25990 
25991  }
25993  WriteToBuf<MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25994  break;
25995 
25996  }
25998  WriteToBuf<VL_MAP_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
25999  break;
26000 
26001  }
26003  WriteToBuf<MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26004  break;
26005 
26006  }
26008  WriteToBuf<MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26009  break;
26010 
26011  }
26013  WriteToBuf<VL_MAP_VL_STRING_PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26014  break;
26015 
26016  }
26018  WriteToBuf<VL_MAP_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26019  break;
26020 
26021  }
26023  WriteToBuf<MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26024  break;
26025 
26026  }
26028  WriteToBuf<VL_MAP_VL_STRING_PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26029  break;
26030 
26031  }
26033  WriteToBuf<MAP_INT_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26034  break;
26035 
26036  }
26038  WriteToBuf<MAP_INT_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26039  break;
26040 
26041  }
26043  WriteToBuf<VL_MAP_INT_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26044  break;
26045 
26046  }
26048  WriteToBuf<VL_MAP_INT_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26049  break;
26050 
26051  }
26053  WriteToBuf<MAP_INT_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26054  break;
26055 
26056  }
26058  WriteToBuf<MAP_INT_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26059  break;
26060 
26061  }
26063  WriteToBuf<VL_MAP_INT_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26064  break;
26065 
26066  }
26068  WriteToBuf<VL_MAP_INT_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26069  break;
26070 
26071  }
26073  WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26074  break;
26075 
26076  }
26078  WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26079  break;
26080 
26081  }
26083  WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26084  break;
26085 
26086  }
26088  WriteToBuf<MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26089  break;
26090 
26091  }
26093  WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26094  break;
26095 
26096  }
26098  WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26099  break;
26100 
26101  }
26103  WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26104  break;
26105 
26106  }
26108  WriteToBuf<MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26109  break;
26110 
26111  }
26113  WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26114  break;
26115 
26116  }
26118  WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26119  break;
26120 
26121  }
26123  WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26124  break;
26125 
26126  }
26128  WriteToBuf<MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26129  break;
26130 
26131  }
26133  WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26134  break;
26135 
26136  }
26138  WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26139  break;
26140 
26141  }
26143  WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26144  break;
26145 
26146  }
26148  WriteToBuf<MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26149  break;
26150 
26151  }
26153  WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26154  break;
26155 
26156  }
26158  WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26159  break;
26160 
26161  }
26163  WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26164  break;
26165 
26166  }
26168  WriteToBuf<VL_MAP_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26169  break;
26170 
26171  }
26173  WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26174  break;
26175 
26176  }
26178  WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26179  break;
26180 
26181  }
26183  WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26184  break;
26185 
26186  }
26188  WriteToBuf<VL_MAP_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26189  break;
26190 
26191  }
26193  WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26194  break;
26195 
26196  }
26198  WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26199  break;
26200 
26201  }
26203  WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26204  break;
26205 
26206  }
26208  WriteToBuf<VL_MAP_VL_STRING_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26209  break;
26210 
26211  }
26213  WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26214  break;
26215 
26216  }
26218  WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26219  break;
26220 
26221  }
26223  WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26224  break;
26225 
26226  }
26228  WriteToBuf<VL_MAP_VL_STRING_VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26229  break;
26230 
26231  }
26232  case LIST_PAIR_INT_INT: {
26233  WriteToBuf<LIST_PAIR_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
26234  break;
26235 
26236  }
26237  case VL_LIST_PAIR_INT_INT: {
26238  WriteToBuf<VL_LIST_PAIR_INT_INT>(buf+offset, shapes[col], a, sizes[col]);
26239  break;
26240 
26241  }
26243  WriteToBuf<MAP_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26244  break;
26245 
26246  }
26248  WriteToBuf<MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26249  break;
26250 
26251  }
26253  WriteToBuf<MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26254  break;
26255 
26256  }
26258  WriteToBuf<MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26259  break;
26260 
26261  }
26263  WriteToBuf<MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26264  break;
26265 
26266  }
26268  WriteToBuf<MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26269  break;
26270 
26271  }
26273  WriteToBuf<MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26274  break;
26275 
26276  }
26278  WriteToBuf<MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26279  break;
26280 
26281  }
26283  WriteToBuf<VL_MAP_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26284  break;
26285 
26286  }
26288  WriteToBuf<VL_MAP_VL_STRING_PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26289  break;
26290 
26291  }
26293  WriteToBuf<VL_MAP_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26294  break;
26295 
26296  }
26298  WriteToBuf<VL_MAP_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26299  break;
26300 
26301  }
26303  WriteToBuf<VL_MAP_VL_STRING_PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26304  break;
26305 
26306  }
26308  WriteToBuf<VL_MAP_VL_STRING_PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26309  break;
26310 
26311  }
26313  WriteToBuf<VL_MAP_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26314  break;
26315 
26316  }
26318  WriteToBuf<VL_MAP_VL_STRING_PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26319  break;
26320 
26321  }
26323  WriteToBuf<MAP_STRING_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26324  break;
26325 
26326  }
26328  WriteToBuf<MAP_STRING_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26329  break;
26330 
26331  }
26333  WriteToBuf<MAP_STRING_VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26334  break;
26335 
26336  }
26338  WriteToBuf<MAP_STRING_VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26339  break;
26340 
26341  }
26343  WriteToBuf<MAP_VL_STRING_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26344  break;
26345 
26346  }
26348  WriteToBuf<MAP_VL_STRING_VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26349  break;
26350 
26351  }
26353  WriteToBuf<MAP_VL_STRING_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26354  break;
26355 
26356  }
26358  WriteToBuf<MAP_VL_STRING_VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26359  break;
26360 
26361  }
26363  WriteToBuf<VL_MAP_STRING_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26364  break;
26365 
26366  }
26368  WriteToBuf<VL_MAP_VL_STRING_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26369  break;
26370 
26371  }
26373  WriteToBuf<VL_MAP_STRING_VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26374  break;
26375 
26376  }
26378  WriteToBuf<VL_MAP_STRING_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26379  break;
26380 
26381  }
26383  WriteToBuf<VL_MAP_STRING_VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26384  break;
26385 
26386  }
26388  WriteToBuf<VL_MAP_VL_STRING_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26389  break;
26390 
26391  }
26393  WriteToBuf<VL_MAP_VL_STRING_VL_MAP_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26394  break;
26395 
26396  }
26398  WriteToBuf<VL_MAP_VL_STRING_VL_MAP_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26399  break;
26400 
26401  }
26403  WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26404  break;
26405 
26406  }
26408  WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26409  break;
26410 
26411  }
26413  WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26414  break;
26415 
26416  }
26418  WriteToBuf<VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26419  break;
26420 
26421  }
26423  WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26424  break;
26425 
26426  }
26428  WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26429  break;
26430 
26431  }
26433  WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26434  break;
26435 
26436  }
26438  WriteToBuf<VL_VECTOR_PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26439  break;
26440 
26441  }
26443  WriteToBuf<PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26444  break;
26445 
26446  }
26448  WriteToBuf<PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26449  break;
26450 
26451  }
26453  WriteToBuf<PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26454  break;
26455 
26456  }
26458  WriteToBuf<PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26459  break;
26460 
26461  }
26462  case PAIR_DOUBLE_DOUBLE: {
26463  WriteToBuf<PAIR_DOUBLE_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26464  break;
26465 
26466  }
26468  WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26469  break;
26470 
26471  }
26473  WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26474  break;
26475 
26476  }
26478  WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26479  break;
26480 
26481  }
26483  WriteToBuf<PAIR_PAIR_DOUBLE_DOUBLE_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26484  break;
26485 
26486  }
26488  WriteToBuf<PAIR_DOUBLE_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26489  break;
26490 
26491  }
26493  WriteToBuf<PAIR_DOUBLE_VL_MAP_INT_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26494  break;
26495 
26496  }
26498  WriteToBuf<VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26499  break;
26500 
26501  }
26503  WriteToBuf<VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26504  break;
26505 
26506  }
26508  WriteToBuf<VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26509  break;
26510 
26511  }
26513  WriteToBuf<VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26514  break;
26515 
26516  }
26518  WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26519  break;
26520 
26521  }
26523  WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_VL_STRING_STRING>(buf+offset, shapes[col], a, sizes[col]);
26524  break;
26525 
26526  }
26528  WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26529  break;
26530 
26531  }
26533  WriteToBuf<VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(buf+offset, shapes[col], a, sizes[col]);
26534  break;
26535 
26536  }
26538  WriteToBuf<PAIR_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26539  break;
26540 
26541  }
26543  WriteToBuf<PAIR_VL_STRING_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26544  break;
26545 
26546  }
26548  WriteToBuf<PAIR_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26549  break;
26550 
26551  }
26553  WriteToBuf<PAIR_VL_STRING_VL_VECTOR_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26554  break;
26555 
26556  }
26558  WriteToBuf<MAP_PAIR_STRING_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26559  break;
26560 
26561  }
26563  WriteToBuf<MAP_PAIR_STRING_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26564  break;
26565 
26566  }
26568  WriteToBuf<MAP_PAIR_VL_STRING_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26569  break;
26570 
26571  }
26573  WriteToBuf<MAP_PAIR_VL_STRING_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26574  break;
26575 
26576  }
26578  WriteToBuf<VL_MAP_PAIR_STRING_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26579  break;
26580 
26581  }
26583  WriteToBuf<VL_MAP_PAIR_STRING_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26584  break;
26585 
26586  }
26588  WriteToBuf<VL_MAP_PAIR_VL_STRING_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26589  break;
26590 
26591  }
26593  WriteToBuf<VL_MAP_PAIR_VL_STRING_VL_STRING_INT>(buf+offset, shapes[col], a, sizes[col]);
26594  break;
26595 
26596  }
26598  WriteToBuf<MAP_STRING_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26599  break;
26600 
26601  }
26603  WriteToBuf<MAP_STRING_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26604  break;
26605 
26606  }
26608  WriteToBuf<MAP_STRING_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26609  break;
26610 
26611  }
26613  WriteToBuf<MAP_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26614  break;
26615 
26616  }
26618  WriteToBuf<MAP_VL_STRING_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26619  break;
26620 
26621  }
26623  WriteToBuf<MAP_VL_STRING_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26624  break;
26625 
26626  }
26628  WriteToBuf<MAP_VL_STRING_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26629  break;
26630 
26631  }
26633  WriteToBuf<MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26634  break;
26635 
26636  }
26638  WriteToBuf<VL_MAP_STRING_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26639  break;
26640 
26641  }
26643  WriteToBuf<VL_MAP_VL_STRING_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26644  break;
26645 
26646  }
26648  WriteToBuf<VL_MAP_STRING_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26649  break;
26650 
26651  }
26653  WriteToBuf<VL_MAP_STRING_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26654  break;
26655 
26656  }
26658  WriteToBuf<VL_MAP_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26659  break;
26660 
26661  }
26663  WriteToBuf<VL_MAP_VL_STRING_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26664  break;
26665 
26666  }
26668  WriteToBuf<VL_MAP_VL_STRING_VL_MAP_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26669  break;
26670 
26671  }
26673  WriteToBuf<VL_MAP_VL_STRING_VL_MAP_VL_STRING_DOUBLE>(buf+offset, shapes[col], a, sizes[col]);
26674  break;
26675 
26676  }
26677 
26678 
26679  default: {
26680  throw ValueError("attempted to retrieve unsupported HDF5 backend type");
26681  }
26682  }
26683  offset += sizes[col];
26684  }
26685  }
26686 }
26687 
26688 template <typename T, DbTypes U>
26689 T Hdf5Back::VLRead(const char* rawkey) {
26690  // key is used as offset
26691  Digest key;
26692  memcpy(key.val, rawkey, CYCLUS_SHA1_SIZE);
26693  const std::vector<hsize_t> idx = key.cast<hsize_t>();
26694  hid_t dset = VLDataset(U, false);
26695  hid_t dspace = H5Dget_space(dset);
26696  hid_t mspace = H5Screate_simple(CYCLUS_SHA1_NINT, vlchunk_, NULL);
26697  herr_t status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, (const hsize_t*) &idx[0],
26698  NULL, vlchunk_, NULL);
26699  if (status < 0)
26700  throw IOError("could not select hyperslab of value array for reading "
26701  "in the database '" + path_ + "'.");
26702  hvl_t buf;
26703  status = H5Dread(dset, vldts_[U], mspace, dspace, H5P_DEFAULT, &buf);
26704  if (status < 0) {
26705  std::stringstream ss;
26706  ss << U;
26707  throw IOError("failed to read in variable length data "
26708  "in the database '" + path_ + "' (type id " + ss.str() +
26709  ").");
26710  }
26711  T val = VLBufToVal<T>(buf);
26712  status = H5Dvlen_reclaim(vldts_[U], mspace, H5P_DEFAULT, &buf);
26713  if (status < 0)
26714  throw IOError("failed to reclaim variable length data space "
26715  "in the database '" + path_ + "'.");
26716  H5Sclose(mspace);
26717  H5Sclose(dspace);
26718  return val;
26719 }
26720 
26721 
26722 hid_t Hdf5Back::VLDataset(DbTypes dbtype, bool forkeys) {
26723  std::string name;
26724  switch (dbtype) {
26725  case VL_STRING: {
26726  name="String";
26727  break;
26728 
26729  }
26730  case BLOB: {
26731  name="Blob";
26732  break;
26733 
26734  }
26735  case VL_VECTOR_INT: {
26736  name="VectorInt";
26737  break;
26738 
26739  }
26740  case VL_VECTOR_FLOAT: {
26741  name="VectorFloat";
26742  break;
26743 
26744  }
26745  case VL_VECTOR_DOUBLE: {
26746  name="VectorDouble";
26747  break;
26748 
26749  }
26750  case VL_VECTOR_STRING: {
26751  name="VectorString";
26752  break;
26753 
26754  }
26755  case VL_VECTOR_VL_STRING: {
26756  name="VectorString";
26757  break;
26758 
26759  }
26760  case VL_VECTOR_BLOB: {
26761  name="VectorBlob";
26762  break;
26763 
26764  }
26765  case VL_VECTOR_UUID: {
26766  name="VectorUuid";
26767  break;
26768 
26769  }
26770  case VL_SET_INT: {
26771  name="SetInt";
26772  break;
26773 
26774  }
26775  case VL_SET_FLOAT: {
26776  name="SetFloat";
26777  break;
26778 
26779  }
26780  case VL_SET_DOUBLE: {
26781  name="SetDouble";
26782  break;
26783 
26784  }
26785  case VL_SET_STRING: {
26786  name="SetString";
26787  break;
26788 
26789  }
26790  case VL_SET_VL_STRING: {
26791  name="SetString";
26792  break;
26793 
26794  }
26795  case VL_SET_BLOB: {
26796  name="SetBlob";
26797  break;
26798 
26799  }
26800  case VL_SET_UUID: {
26801  name="SetUuid";
26802  break;
26803 
26804  }
26805  case VL_LIST_BOOL: {
26806  name="ListBool";
26807  break;
26808 
26809  }
26810  case VL_LIST_INT: {
26811  name="ListInt";
26812  break;
26813 
26814  }
26815  case VL_LIST_FLOAT: {
26816  name="ListFloat";
26817  break;
26818 
26819  }
26820  case VL_LIST_DOUBLE: {
26821  name="ListDouble";
26822  break;
26823 
26824  }
26825  case VL_LIST_STRING: {
26826  name="ListString";
26827  break;
26828 
26829  }
26830  case VL_LIST_VL_STRING: {
26831  name="ListString";
26832  break;
26833 
26834  }
26835  case VL_LIST_BLOB: {
26836  name="ListBlob";
26837  break;
26838 
26839  }
26840  case VL_LIST_UUID: {
26841  name="ListUuid";
26842  break;
26843 
26844  }
26845  case VL_MAP_INT_BOOL: {
26846  name="MapIntBool";
26847  break;
26848 
26849  }
26850  case VL_MAP_INT_INT: {
26851  name="MapIntInt";
26852  break;
26853 
26854  }
26855  case VL_MAP_INT_FLOAT: {
26856  name="MapIntFloat";
26857  break;
26858 
26859  }
26860  case VL_MAP_INT_DOUBLE: {
26861  name="MapIntDouble";
26862  break;
26863 
26864  }
26865  case VL_MAP_INT_STRING: {
26866  name="MapIntString";
26867  break;
26868 
26869  }
26870  case VL_MAP_INT_VL_STRING: {
26871  name="MapIntString";
26872  break;
26873 
26874  }
26875  case VL_MAP_INT_BLOB: {
26876  name="MapIntBlob";
26877  break;
26878 
26879  }
26880  case VL_MAP_INT_UUID: {
26881  name="MapIntUuid";
26882  break;
26883 
26884  }
26885  case VL_MAP_STRING_BOOL: {
26886  name="MapStringBool";
26887  break;
26888 
26889  }
26890  case VL_MAP_VL_STRING_BOOL: {
26891  name="MapStringBool";
26892  break;
26893 
26894  }
26895  case VL_MAP_STRING_INT: {
26896  name="MapStringInt";
26897  break;
26898 
26899  }
26900  case VL_MAP_VL_STRING_INT: {
26901  name="MapStringInt";
26902  break;
26903 
26904  }
26905  case VL_MAP_STRING_FLOAT: {
26906  name="MapStringFloat";
26907  break;
26908 
26909  }
26910  case VL_MAP_VL_STRING_FLOAT: {
26911  name="MapStringFloat";
26912  break;
26913 
26914  }
26915  case VL_MAP_STRING_DOUBLE: {
26916  name="MapStringDouble";
26917  break;
26918 
26919  }
26920  case VL_MAP_VL_STRING_DOUBLE: {
26921  name="MapStringDouble";
26922  break;
26923 
26924  }
26925  case VL_MAP_STRING_STRING: {
26926  name="MapStringString";
26927  break;
26928 
26929  }
26930  case VL_MAP_STRING_VL_STRING: {
26931  name="MapStringString";
26932  break;
26933 
26934  }
26935  case VL_MAP_VL_STRING_STRING: {
26936  name="MapStringString";
26937  break;
26938 
26939  }
26941  name="MapStringString";
26942  break;
26943 
26944  }
26945  case VL_MAP_STRING_BLOB: {
26946  name="MapStringBlob";
26947  break;
26948 
26949  }
26950  case VL_MAP_VL_STRING_BLOB: {
26951  name="MapStringBlob";
26952  break;
26953 
26954  }
26955  case VL_MAP_STRING_UUID: {
26956  name="MapStringUuid";
26957  break;
26958 
26959  }
26960  case VL_MAP_VL_STRING_UUID: {
26961  name="MapStringUuid";
26962  break;
26963 
26964  }
26966  name="MapPairIntStringDouble";
26967  break;
26968 
26969  }
26971  name="MapPairIntStringDouble";
26972  break;
26973 
26974  }
26976  name="MapStringVectorDouble";
26977  break;
26978 
26979  }
26981  name="MapStringVectorDouble";
26982  break;
26983 
26984  }
26986  name="MapStringVectorDouble";
26987  break;
26988 
26989  }
26991  name="MapStringVectorDouble";
26992  break;
26993 
26994  }
26996  name="MapStringMapIntDouble";
26997  break;
26998 
26999  }
27001  name="MapStringMapIntDouble";
27002  break;
27003 
27004  }
27006  name="MapStringMapIntDouble";
27007  break;
27008 
27009  }
27011  name="MapStringMapIntDouble";
27012  break;
27013 
27014  }
27016  name="MapStringPairDoubleMapIntDouble";
27017  break;
27018 
27019  }
27021  name="MapStringPairDoubleMapIntDouble";
27022  break;
27023 
27024  }
27026  name="MapStringPairDoubleMapIntDouble";
27027  break;
27028 
27029  }
27031  name="MapStringPairDoubleMapIntDouble";
27032  break;
27033 
27034  }
27036  name="MapIntMapStringDouble";
27037  break;
27038 
27039  }
27041  name="MapIntMapStringDouble";
27042  break;
27043 
27044  }
27046  name="MapIntMapStringDouble";
27047  break;
27048 
27049  }
27051  name="MapIntMapStringDouble";
27052  break;
27053 
27054  }
27056  name="MapStringVectorPairIntPairStringString";
27057  break;
27058 
27059  }
27061  name="MapStringVectorPairIntPairStringString";
27062  break;
27063 
27064  }
27066  name="MapStringVectorPairIntPairStringString";
27067  break;
27068 
27069  }
27071  name="MapStringVectorPairIntPairStringString";
27072  break;
27073 
27074  }
27076  name="MapStringVectorPairIntPairStringString";
27077  break;
27078 
27079  }
27081  name="MapStringVectorPairIntPairStringString";
27082  break;
27083 
27084  }
27086  name="MapStringVectorPairIntPairStringString";
27087  break;
27088 
27089  }
27091  name="MapStringVectorPairIntPairStringString";
27092  break;
27093 
27094  }
27096  name="MapStringVectorPairIntPairStringString";
27097  break;
27098 
27099  }
27101  name="MapStringVectorPairIntPairStringString";
27102  break;
27103 
27104  }
27106  name="MapStringVectorPairIntPairStringString";
27107  break;
27108 
27109  }
27111  name="MapStringVectorPairIntPairStringString";
27112  break;
27113 
27114  }
27116  name="MapStringVectorPairIntPairStringString";
27117  break;
27118 
27119  }
27121  name="MapStringVectorPairIntPairStringString";
27122  break;
27123 
27124  }
27126  name="MapStringVectorPairIntPairStringString";
27127  break;
27128 
27129  }
27131  name="MapStringVectorPairIntPairStringString";
27132  break;
27133 
27134  }
27135  case VL_LIST_PAIR_INT_INT: {
27136  name="ListPairIntInt";
27137  break;
27138 
27139  }
27141  name="MapStringPairStringVectorDouble";
27142  break;
27143 
27144  }
27146  name="MapStringPairStringVectorDouble";
27147  break;
27148 
27149  }
27151  name="MapStringPairStringVectorDouble";
27152  break;
27153 
27154  }
27156  name="MapStringPairStringVectorDouble";
27157  break;
27158 
27159  }
27161  name="MapStringPairStringVectorDouble";
27162  break;
27163 
27164  }
27166  name="MapStringPairStringVectorDouble";
27167  break;
27168 
27169  }
27171  name="MapStringPairStringVectorDouble";
27172  break;
27173 
27174  }
27176  name="MapStringPairStringVectorDouble";
27177  break;
27178 
27179  }
27181  name="MapStringMapStringInt";
27182  break;
27183 
27184  }
27186  name="MapStringMapStringInt";
27187  break;
27188 
27189  }
27191  name="MapStringMapStringInt";
27192  break;
27193 
27194  }
27196  name="MapStringMapStringInt";
27197  break;
27198 
27199  }
27201  name="MapStringMapStringInt";
27202  break;
27203 
27204  }
27206  name="MapStringMapStringInt";
27207  break;
27208 
27209  }
27211  name="MapStringMapStringInt";
27212  break;
27213 
27214  }
27216  name="MapStringMapStringInt";
27217  break;
27218 
27219  }
27221  name="VectorPairPairDoubleDoubleMapStringDouble";
27222  break;
27223 
27224  }
27226  name="VectorPairPairDoubleDoubleMapStringDouble";
27227  break;
27228 
27229  }
27231  name="VectorPairPairDoubleDoubleMapStringDouble";
27232  break;
27233 
27234  }
27236  name="VectorPairPairDoubleDoubleMapStringDouble";
27237  break;
27238 
27239  }
27241  name="VectorPairIntPairStringString";
27242  break;
27243 
27244  }
27246  name="VectorPairIntPairStringString";
27247  break;
27248 
27249  }
27251  name="VectorPairIntPairStringString";
27252  break;
27253 
27254  }
27256  name="VectorPairIntPairStringString";
27257  break;
27258 
27259  }
27261  name="MapPairStringStringInt";
27262  break;
27263 
27264  }
27266  name="MapPairStringStringInt";
27267  break;
27268 
27269  }
27271  name="MapPairStringStringInt";
27272  break;
27273 
27274  }
27276  name="MapPairStringStringInt";
27277  break;
27278 
27279  }
27281  name="MapStringMapStringDouble";
27282  break;
27283 
27284  }
27286  name="MapStringMapStringDouble";
27287  break;
27288 
27289  }
27291  name="MapStringMapStringDouble";
27292  break;
27293 
27294  }
27296  name="MapStringMapStringDouble";
27297  break;
27298 
27299  }
27301  name="MapStringMapStringDouble";
27302  break;
27303 
27304  }
27306  name="MapStringMapStringDouble";
27307  break;
27308 
27309  }
27311  name="MapStringMapStringDouble";
27312  break;
27313 
27314  }
27316  name="MapStringMapStringDouble";
27317  break;
27318 
27319  }
27320 
27321 
27322  default: {
27323  throw IOError("could not determine variable length dataset name.");
27324  break;
27325  }
27326  }
27327  name += forkeys ? "Keys" : "Vals";
27328 
27329  // already opened
27330  if (vldatasets_.count(name) > 0)
27331  return vldatasets_[name];
27332 
27333  // already in db
27334  hid_t dt;
27335  hid_t dset;
27336  hid_t dspace;
27337  herr_t status;
27338  if (H5Lexists(file_, name.c_str(), H5P_DEFAULT)) {
27339  dset = H5Dopen2(file_, name.c_str(), H5P_DEFAULT);
27340  if (forkeys) {
27341  // read in existing keys to vlkeys_
27342  dspace = H5Dget_space(dset);
27343  unsigned int nkeys = H5Sget_simple_extent_npoints(dspace);
27344  char* buf = new char[CYCLUS_SHA1_SIZE * nkeys];
27345  status = H5Dread(dset, sha1_type_, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf);
27346  if (status < 0)
27347  throw IOError("failed to read in keys for " + name);
27348  for (int n = 0; n < nkeys; ++n) {
27349  Digest d = Digest();
27350  memcpy(d.val, buf + (n * CYCLUS_SHA1_SIZE), CYCLUS_SHA1_SIZE);
27351  vlkeys_[dbtype].insert(d);
27352  }
27353  H5Sclose(dspace);
27354  delete[] buf;
27355  } else {
27356  if (vldts_.count(dbtype) == 0) {
27357  dt = H5Dget_type(dset);
27358  if (dt < 0)
27359  throw IOError("failed to read in HDF5 datatype for " + name);
27360  vldts_[dbtype] = dt;
27361  }
27362  }
27363  vldatasets_[name] = dset;
27364  return dset;
27365  }
27366 
27367  // doesn't exist at all
27368  hid_t prop;
27369  if (forkeys) {
27370  hsize_t dims[1] = {0};
27371  hsize_t maxdims[1] = {H5S_UNLIMITED};
27372  hsize_t chunkdims[1] = {512}; // this is a 10 kb chunksize
27373  dt = sha1_type_;
27374  dspace = H5Screate_simple(1, dims, maxdims);
27375  prop = H5Pcreate(H5P_DATASET_CREATE);
27376  status = H5Pset_chunk(prop, 1, chunkdims);
27377  if (status < 0)
27378  throw IOError("could not create HDF5 array " + name);
27379  } else {
27380  hsize_t dims[CYCLUS_SHA1_NINT] = {UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX, UINT_MAX};
27381  hsize_t chunkdims[CYCLUS_SHA1_NINT] = {1, 1, 1, 1, 1}; // this is a single element
27382  dt = vldts_[dbtype];
27383  dspace = H5Screate_simple(CYCLUS_SHA1_NINT, dims, dims);
27384  prop = H5Pcreate(H5P_DATASET_CREATE);
27385  status = H5Pset_chunk(prop, CYCLUS_SHA1_NINT, chunkdims);
27386  if (status < 0)
27387  throw IOError("could not create HDF5 array " + name);
27388  }
27389  dset = H5Dcreate2(file_, name.c_str(), dt, dspace, H5P_DEFAULT, prop, H5P_DEFAULT);
27390  vldatasets_[name] = dset;
27391  return dset;
27392 }
27393 
27394 void Hdf5Back::AppendVLKey(hid_t dset, DbTypes dbtype, const Digest& key) {
27395  hid_t dspace = H5Dget_space(dset);
27396  hsize_t origlen = H5Sget_simple_extent_npoints(dspace);
27397  hsize_t newlen[1] = {origlen + 1};
27398  hsize_t offset[1] = {origlen};
27399  hsize_t extent[1] = {1};
27400  hid_t mspace = H5Screate_simple(1, extent, NULL);
27401  herr_t status = H5Dextend(dset, newlen);
27402  if (status < 0)
27403  throw IOError("could not resize key array in the database '" + path_ + "'.");
27404  dspace = H5Dget_space(dset);
27405  status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, offset, NULL, extent, NULL);
27406  if (status < 0)
27407  throw IOError("could not select hyperslab of key array "
27408  "in the database '" + path_ + "'.");
27409  status = H5Dwrite(dset, sha1_type_, mspace, dspace, H5P_DEFAULT, key.val);
27410  if (status < 0)
27411  throw IOError("could not write digest to key array "
27412  "in the database '" + path_ + "'.");
27413  H5Sclose(mspace);
27414  H5Sclose(dspace);
27415  vlkeys_[dbtype].insert(key);
27416 }
27417 
27418 void Hdf5Back::InsertVLVal(hid_t dset, DbTypes dbtype, const Digest& key,
27419  const std::string& val) {
27420  hid_t dspace = H5Dget_space(dset);
27421  hsize_t extent[CYCLUS_SHA1_NINT] = {1, 1, 1, 1, 1};
27422  hid_t mspace = H5Screate_simple(CYCLUS_SHA1_NINT, extent, NULL);
27423  const std::vector<hsize_t> idx = key.cast<hsize_t>();
27424  herr_t status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, (const hsize_t*) &idx[0],
27425  NULL, extent, NULL);
27426  if (status < 0)
27427  throw IOError("could not select hyperslab of value array "
27428  "in the database '" + path_ + "'.");
27429  const char* buf[1] = {val.c_str()};
27430  status = H5Dwrite(dset, vldts_[dbtype], mspace, dspace, H5P_DEFAULT, buf);
27431  if (status < 0)
27432  throw IOError("could not write string to value array "
27433  "in the database '" + path_ + "'.");
27434  H5Sclose(mspace);
27435  H5Sclose(dspace);
27436 }
27437 
27438 void Hdf5Back::InsertVLVal(hid_t dset, DbTypes dbtype, const Digest& key,
27439  hvl_t buf) {
27440  hid_t dspace = H5Dget_space(dset);
27441  hsize_t extent[CYCLUS_SHA1_NINT] = {1, 1, 1, 1, 1};
27442  hid_t mspace = H5Screate_simple(CYCLUS_SHA1_NINT, extent, NULL);
27443  const std::vector<hsize_t> idx = key.cast<hsize_t>();
27444  herr_t status = H5Sselect_hyperslab(dspace, H5S_SELECT_SET, (const hsize_t*) &idx[0],
27445  NULL, extent, NULL);
27446  if (status < 0)
27447  throw IOError("could not select hyperslab of value array "
27448  "in the database '" + path_ + "'.");
27449  status = H5Dwrite(dset, vldts_[dbtype], mspace, dspace, H5P_DEFAULT, &buf);
27450  if (status < 0)
27451  throw IOError("could not write variable length data to value array "
27452  "in the database '" + path_ + "'.");
27453  status = H5Dvlen_reclaim(vldts_[dbtype], mspace, H5P_DEFAULT, &buf);
27454  if (status < 0)
27455  throw IOError("could not free variable length buffer "
27456  "in the database '" + path_ + "'.");
27457  H5Sclose(mspace);
27458  H5Sclose(dspace);
27459 }
27460 
27461 hvl_t Hdf5Back::VLValToBuf(const std::vector<int>& x) {
27462  hvl_t buf;
27463  buf.len=x.size();
27464  size_t item_size1elem=sizeof(int);
27465  size_t total_item_size0=item_size1elem;
27466  size_t nbytes=total_item_size0*buf.len;
27467  buf.p=new char[nbytes];
27468  unsigned int count0=0;
27469  std::vector<int>::const_iterator it0=x.begin();
27470  for(;it0!=x.end();++it0){
27471  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27472  ++count0;
27473 
27474  }
27475  return buf;
27476 }
27477 hvl_t Hdf5Back::VLValToBuf(const std::vector<float>& x) {
27478  hvl_t buf;
27479  buf.len=x.size();
27480  size_t item_size1elem=sizeof(float);
27481  size_t total_item_size0=item_size1elem;
27482  size_t nbytes=total_item_size0*buf.len;
27483  buf.p=new char[nbytes];
27484  unsigned int count0=0;
27485  std::vector<float>::const_iterator it0=x.begin();
27486  for(;it0!=x.end();++it0){
27487  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27488  ++count0;
27489 
27490  }
27491  return buf;
27492 }
27493 hvl_t Hdf5Back::VLValToBuf(const std::vector<double>& x) {
27494  hvl_t buf;
27495  buf.len=x.size();
27496  size_t item_size1elem=sizeof(double);
27497  size_t total_item_size0=item_size1elem;
27498  size_t nbytes=total_item_size0*buf.len;
27499  buf.p=new char[nbytes];
27500  unsigned int count0=0;
27501  std::vector<double>::const_iterator it0=x.begin();
27502  for(;it0!=x.end();++it0){
27503  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27504  ++count0;
27505 
27506  }
27507  return buf;
27508 }
27509 hvl_t Hdf5Back::VLValToBuf(const std::vector<std::string>& x) {
27510  hvl_t buf;
27511  buf.len=x.size();
27512  size_t item_size1elem=CYCLUS_SHA1_SIZE;
27513  size_t total_item_size0=item_size1elem;
27514  size_t nbytes=total_item_size0*buf.len;
27515  buf.p=new char[nbytes];
27516  unsigned int count0=0;
27517  std::vector<std::string>::const_iterator it0=x.begin();
27518  for(;it0!=x.end();++it0){
27519  hasher_.Clear();
27520  hasher_.Update((*it0));
27521  Digest key1elem = hasher_.digest();
27522  hid_t keysds1elem = VLDataset(VL_STRING, true);
27523  hid_t valsds1elem = VLDataset(VL_STRING, false);
27524  if (vlkeys_[VL_STRING].count(key1elem) != 1) {
27525  AppendVLKey(keysds1elem, VL_STRING, key1elem);
27526  InsertVLVal(valsds1elem, VL_STRING, key1elem, (*it0));
27527  }
27528  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.val, item_size1elem);
27529  ++count0;
27530 
27531  }
27532  return buf;
27533 }
27534 hvl_t Hdf5Back::VLValToBuf(const std::vector<cyclus::Blob>& x) {
27535  hvl_t buf;
27536  buf.len=x.size();
27537  size_t item_size1elem=CYCLUS_SHA1_SIZE;
27538  size_t total_item_size0=item_size1elem;
27539  size_t nbytes=total_item_size0*buf.len;
27540  buf.p=new char[nbytes];
27541  unsigned int count0=0;
27542  std::vector<cyclus::Blob>::const_iterator it0=x.begin();
27543  for(;it0!=x.end();++it0){
27544  hasher_.Clear();
27545  hasher_.Update((*it0));
27546  Digest key1elem = hasher_.digest();
27547  hid_t keysds1elem = VLDataset(BLOB, true);
27548  hid_t valsds1elem = VLDataset(BLOB, false);
27549  if (vlkeys_[BLOB].count(key1elem) != 1) {
27550  AppendVLKey(keysds1elem, BLOB, key1elem);
27551  InsertVLVal(valsds1elem, BLOB, key1elem, ((*it0)).str());
27552  }
27553  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.val, item_size1elem);
27554  ++count0;
27555 
27556  }
27557  return buf;
27558 }
27559 hvl_t Hdf5Back::VLValToBuf(const std::vector<boost::uuids::uuid>& x) {
27560  hvl_t buf;
27561  buf.len=x.size();
27562  size_t item_size1elem=CYCLUS_UUID_SIZE;
27563  size_t total_item_size0=item_size1elem;
27564  size_t nbytes=total_item_size0*buf.len;
27565  buf.p=new char[nbytes];
27566  unsigned int count0=0;
27567  std::vector<boost::uuids::uuid>::const_iterator it0=x.begin();
27568  for(;it0!=x.end();++it0){
27569  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27570  ++count0;
27571 
27572  }
27573  return buf;
27574 }
27575 hvl_t Hdf5Back::VLValToBuf(const std::set<int>& x) {
27576  hvl_t buf;
27577  buf.len=x.size();
27578  size_t item_size1elem=sizeof(int);
27579  size_t total_item_size0=item_size1elem;
27580  size_t nbytes=total_item_size0*buf.len;
27581  buf.p=new char[nbytes];
27582  unsigned int count0=0;
27583  std::set<int>::const_iterator it0=x.begin();
27584  for(;it0!=x.end();++it0){
27585  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27586  ++count0;
27587 
27588  }
27589  return buf;
27590 }
27591 hvl_t Hdf5Back::VLValToBuf(const std::set<float>& x) {
27592  hvl_t buf;
27593  buf.len=x.size();
27594  size_t item_size1elem=sizeof(float);
27595  size_t total_item_size0=item_size1elem;
27596  size_t nbytes=total_item_size0*buf.len;
27597  buf.p=new char[nbytes];
27598  unsigned int count0=0;
27599  std::set<float>::const_iterator it0=x.begin();
27600  for(;it0!=x.end();++it0){
27601  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27602  ++count0;
27603 
27604  }
27605  return buf;
27606 }
27607 hvl_t Hdf5Back::VLValToBuf(const std::set<double>& x) {
27608  hvl_t buf;
27609  buf.len=x.size();
27610  size_t item_size1elem=sizeof(double);
27611  size_t total_item_size0=item_size1elem;
27612  size_t nbytes=total_item_size0*buf.len;
27613  buf.p=new char[nbytes];
27614  unsigned int count0=0;
27615  std::set<double>::const_iterator it0=x.begin();
27616  for(;it0!=x.end();++it0){
27617  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27618  ++count0;
27619 
27620  }
27621  return buf;
27622 }
27623 hvl_t Hdf5Back::VLValToBuf(const std::set<std::string>& x) {
27624  hvl_t buf;
27625  buf.len=x.size();
27626  size_t item_size1elem=CYCLUS_SHA1_SIZE;
27627  size_t total_item_size0=item_size1elem;
27628  size_t nbytes=total_item_size0*buf.len;
27629  buf.p=new char[nbytes];
27630  unsigned int count0=0;
27631  std::set<std::string>::const_iterator it0=x.begin();
27632  for(;it0!=x.end();++it0){
27633  hasher_.Clear();
27634  hasher_.Update((*it0));
27635  Digest key1elem = hasher_.digest();
27636  hid_t keysds1elem = VLDataset(VL_STRING, true);
27637  hid_t valsds1elem = VLDataset(VL_STRING, false);
27638  if (vlkeys_[VL_STRING].count(key1elem) != 1) {
27639  AppendVLKey(keysds1elem, VL_STRING, key1elem);
27640  InsertVLVal(valsds1elem, VL_STRING, key1elem, (*it0));
27641  }
27642  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.val, item_size1elem);
27643  ++count0;
27644 
27645  }
27646  return buf;
27647 }
27648 hvl_t Hdf5Back::VLValToBuf(const std::set<cyclus::Blob>& x) {
27649  hvl_t buf;
27650  buf.len=x.size();
27651  size_t item_size1elem=CYCLUS_SHA1_SIZE;
27652  size_t total_item_size0=item_size1elem;
27653  size_t nbytes=total_item_size0*buf.len;
27654  buf.p=new char[nbytes];
27655  unsigned int count0=0;
27656  std::set<cyclus::Blob>::const_iterator it0=x.begin();
27657  for(;it0!=x.end();++it0){
27658  hasher_.Clear();
27659  hasher_.Update((*it0));
27660  Digest key1elem = hasher_.digest();
27661  hid_t keysds1elem = VLDataset(BLOB, true);
27662  hid_t valsds1elem = VLDataset(BLOB, false);
27663  if (vlkeys_[BLOB].count(key1elem) != 1) {
27664  AppendVLKey(keysds1elem, BLOB, key1elem);
27665  InsertVLVal(valsds1elem, BLOB, key1elem, ((*it0)).str());
27666  }
27667  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.val, item_size1elem);
27668  ++count0;
27669 
27670  }
27671  return buf;
27672 }
27673 hvl_t Hdf5Back::VLValToBuf(const std::set<boost::uuids::uuid>& x) {
27674  hvl_t buf;
27675  buf.len=x.size();
27676  size_t item_size1elem=CYCLUS_UUID_SIZE;
27677  size_t total_item_size0=item_size1elem;
27678  size_t nbytes=total_item_size0*buf.len;
27679  buf.p=new char[nbytes];
27680  unsigned int count0=0;
27681  std::set<boost::uuids::uuid>::const_iterator it0=x.begin();
27682  for(;it0!=x.end();++it0){
27683  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27684  ++count0;
27685 
27686  }
27687  return buf;
27688 }
27689 hvl_t Hdf5Back::VLValToBuf(const std::list<bool>& x) {
27690  hvl_t buf;
27691  buf.len=x.size();
27692  size_t item_size1elem=sizeof(char);
27693  size_t total_item_size0=item_size1elem;
27694  size_t nbytes=total_item_size0*buf.len;
27695  buf.p=new char[nbytes];
27696  unsigned int count0=0;
27697  std::list<bool>::const_iterator it0=x.begin();
27698  for(;it0!=x.end();++it0){
27699  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27700  ++count0;
27701 
27702  }
27703  return buf;
27704 }
27705 hvl_t Hdf5Back::VLValToBuf(const std::list<int>& x) {
27706  hvl_t buf;
27707  buf.len=x.size();
27708  size_t item_size1elem=sizeof(int);
27709  size_t total_item_size0=item_size1elem;
27710  size_t nbytes=total_item_size0*buf.len;
27711  buf.p=new char[nbytes];
27712  unsigned int count0=0;
27713  std::list<int>::const_iterator it0=x.begin();
27714  for(;it0!=x.end();++it0){
27715  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27716  ++count0;
27717 
27718  }
27719  return buf;
27720 }
27721 hvl_t Hdf5Back::VLValToBuf(const std::list<float>& x) {
27722  hvl_t buf;
27723  buf.len=x.size();
27724  size_t item_size1elem=sizeof(float);
27725  size_t total_item_size0=item_size1elem;
27726  size_t nbytes=total_item_size0*buf.len;
27727  buf.p=new char[nbytes];
27728  unsigned int count0=0;
27729  std::list<float>::const_iterator it0=x.begin();
27730  for(;it0!=x.end();++it0){
27731  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27732  ++count0;
27733 
27734  }
27735  return buf;
27736 }
27737 hvl_t Hdf5Back::VLValToBuf(const std::list<double>& x) {
27738  hvl_t buf;
27739  buf.len=x.size();
27740  size_t item_size1elem=sizeof(double);
27741  size_t total_item_size0=item_size1elem;
27742  size_t nbytes=total_item_size0*buf.len;
27743  buf.p=new char[nbytes];
27744  unsigned int count0=0;
27745  std::list<double>::const_iterator it0=x.begin();
27746  for(;it0!=x.end();++it0){
27747  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27748  ++count0;
27749 
27750  }
27751  return buf;
27752 }
27753 hvl_t Hdf5Back::VLValToBuf(const std::list<std::string>& x) {
27754  hvl_t buf;
27755  buf.len=x.size();
27756  size_t item_size1elem=CYCLUS_SHA1_SIZE;
27757  size_t total_item_size0=item_size1elem;
27758  size_t nbytes=total_item_size0*buf.len;
27759  buf.p=new char[nbytes];
27760  unsigned int count0=0;
27761  std::list<std::string>::const_iterator it0=x.begin();
27762  for(;it0!=x.end();++it0){
27763  hasher_.Clear();
27764  hasher_.Update((*it0));
27765  Digest key1elem = hasher_.digest();
27766  hid_t keysds1elem = VLDataset(VL_STRING, true);
27767  hid_t valsds1elem = VLDataset(VL_STRING, false);
27768  if (vlkeys_[VL_STRING].count(key1elem) != 1) {
27769  AppendVLKey(keysds1elem, VL_STRING, key1elem);
27770  InsertVLVal(valsds1elem, VL_STRING, key1elem, (*it0));
27771  }
27772  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.val, item_size1elem);
27773  ++count0;
27774 
27775  }
27776  return buf;
27777 }
27778 hvl_t Hdf5Back::VLValToBuf(const std::list<cyclus::Blob>& x) {
27779  hvl_t buf;
27780  buf.len=x.size();
27781  size_t item_size1elem=CYCLUS_SHA1_SIZE;
27782  size_t total_item_size0=item_size1elem;
27783  size_t nbytes=total_item_size0*buf.len;
27784  buf.p=new char[nbytes];
27785  unsigned int count0=0;
27786  std::list<cyclus::Blob>::const_iterator it0=x.begin();
27787  for(;it0!=x.end();++it0){
27788  hasher_.Clear();
27789  hasher_.Update((*it0));
27790  Digest key1elem = hasher_.digest();
27791  hid_t keysds1elem = VLDataset(BLOB, true);
27792  hid_t valsds1elem = VLDataset(BLOB, false);
27793  if (vlkeys_[BLOB].count(key1elem) != 1) {
27794  AppendVLKey(keysds1elem, BLOB, key1elem);
27795  InsertVLVal(valsds1elem, BLOB, key1elem, ((*it0)).str());
27796  }
27797  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1elem.val, item_size1elem);
27798  ++count0;
27799 
27800  }
27801  return buf;
27802 }
27803 hvl_t Hdf5Back::VLValToBuf(const std::list<boost::uuids::uuid>& x) {
27804  hvl_t buf;
27805  buf.len=x.size();
27806  size_t item_size1elem=CYCLUS_UUID_SIZE;
27807  size_t total_item_size0=item_size1elem;
27808  size_t nbytes=total_item_size0*buf.len;
27809  buf.p=new char[nbytes];
27810  unsigned int count0=0;
27811  std::list<boost::uuids::uuid>::const_iterator it0=x.begin();
27812  for(;it0!=x.end();++it0){
27813  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0)), item_size1elem);
27814  ++count0;
27815 
27816  }
27817  return buf;
27818 }
27819 hvl_t Hdf5Back::VLValToBuf(const std::map<int, bool>& x) {
27820  hvl_t buf;
27821  buf.len=x.size();
27822  size_t item_size1key=sizeof(int);
27823  size_t item_size1val=sizeof(char);
27824  size_t total_item_size0=item_size1key+item_size1val;
27825  size_t nbytes=total_item_size0*buf.len;
27826  buf.p=new char[nbytes];
27827  unsigned int count0=0;
27828  std::map<int, bool>::const_iterator it0=x.begin();
27829  for(;it0!=x.end();++it0){
27830  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27831  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27832  ++count0;
27833 
27834  }
27835  return buf;
27836 }
27837 hvl_t Hdf5Back::VLValToBuf(const std::map<int, int>& x) {
27838  hvl_t buf;
27839  buf.len=x.size();
27840  size_t item_size1key=sizeof(int);
27841  size_t item_size1val=sizeof(int);
27842  size_t total_item_size0=item_size1key+item_size1val;
27843  size_t nbytes=total_item_size0*buf.len;
27844  buf.p=new char[nbytes];
27845  unsigned int count0=0;
27846  std::map<int, int>::const_iterator it0=x.begin();
27847  for(;it0!=x.end();++it0){
27848  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27849  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27850  ++count0;
27851 
27852  }
27853  return buf;
27854 }
27855 hvl_t Hdf5Back::VLValToBuf(const std::map<int, float>& x) {
27856  hvl_t buf;
27857  buf.len=x.size();
27858  size_t item_size1key=sizeof(int);
27859  size_t item_size1val=sizeof(float);
27860  size_t total_item_size0=item_size1key+item_size1val;
27861  size_t nbytes=total_item_size0*buf.len;
27862  buf.p=new char[nbytes];
27863  unsigned int count0=0;
27864  std::map<int, float>::const_iterator it0=x.begin();
27865  for(;it0!=x.end();++it0){
27866  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27867  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27868  ++count0;
27869 
27870  }
27871  return buf;
27872 }
27873 hvl_t Hdf5Back::VLValToBuf(const std::map<int, double>& x) {
27874  hvl_t buf;
27875  buf.len=x.size();
27876  size_t item_size1key=sizeof(int);
27877  size_t item_size1val=sizeof(double);
27878  size_t total_item_size0=item_size1key+item_size1val;
27879  size_t nbytes=total_item_size0*buf.len;
27880  buf.p=new char[nbytes];
27881  unsigned int count0=0;
27882  std::map<int, double>::const_iterator it0=x.begin();
27883  for(;it0!=x.end();++it0){
27884  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27885  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27886  ++count0;
27887 
27888  }
27889  return buf;
27890 }
27891 hvl_t Hdf5Back::VLValToBuf(const std::map<int, std::string>& x) {
27892  hvl_t buf;
27893  buf.len=x.size();
27894  size_t item_size1key=sizeof(int);
27895  size_t item_size1val=CYCLUS_SHA1_SIZE;
27896  size_t total_item_size0=item_size1key+item_size1val;
27897  size_t nbytes=total_item_size0*buf.len;
27898  buf.p=new char[nbytes];
27899  unsigned int count0=0;
27900  std::map<int, std::string>::const_iterator it0=x.begin();
27901  for(;it0!=x.end();++it0){
27902  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27903  hasher_.Clear();
27904  hasher_.Update(it0->second);
27905  Digest key1val = hasher_.digest();
27906  hid_t keysds1val = VLDataset(VL_STRING, true);
27907  hid_t valsds1val = VLDataset(VL_STRING, false);
27908  if (vlkeys_[VL_STRING].count(key1val) != 1) {
27909  AppendVLKey(keysds1val, VL_STRING, key1val);
27910  InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
27911  }
27912  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
27913  ++count0;
27914 
27915  }
27916  return buf;
27917 }
27918 hvl_t Hdf5Back::VLValToBuf(const std::map<int, cyclus::Blob>& x) {
27919  hvl_t buf;
27920  buf.len=x.size();
27921  size_t item_size1key=sizeof(int);
27922  size_t item_size1val=CYCLUS_SHA1_SIZE;
27923  size_t total_item_size0=item_size1key+item_size1val;
27924  size_t nbytes=total_item_size0*buf.len;
27925  buf.p=new char[nbytes];
27926  unsigned int count0=0;
27927  std::map<int, cyclus::Blob>::const_iterator it0=x.begin();
27928  for(;it0!=x.end();++it0){
27929  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27930  hasher_.Clear();
27931  hasher_.Update(it0->second);
27932  Digest key1val = hasher_.digest();
27933  hid_t keysds1val = VLDataset(BLOB, true);
27934  hid_t valsds1val = VLDataset(BLOB, false);
27935  if (vlkeys_[BLOB].count(key1val) != 1) {
27936  AppendVLKey(keysds1val, BLOB, key1val);
27937  InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
27938  }
27939  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
27940  ++count0;
27941 
27942  }
27943  return buf;
27944 }
27945 hvl_t Hdf5Back::VLValToBuf(const std::map<int, boost::uuids::uuid>& x) {
27946  hvl_t buf;
27947  buf.len=x.size();
27948  size_t item_size1key=sizeof(int);
27949  size_t item_size1val=CYCLUS_UUID_SIZE;
27950  size_t total_item_size0=item_size1key+item_size1val;
27951  size_t nbytes=total_item_size0*buf.len;
27952  buf.p=new char[nbytes];
27953  unsigned int count0=0;
27954  std::map<int, boost::uuids::uuid>::const_iterator it0=x.begin();
27955  for(;it0!=x.end();++it0){
27956  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
27957  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27958  ++count0;
27959 
27960  }
27961  return buf;
27962 }
27963 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, bool>& x) {
27964  hvl_t buf;
27965  buf.len=x.size();
27966  size_t item_size1key=CYCLUS_SHA1_SIZE;
27967  size_t item_size1val=sizeof(char);
27968  size_t total_item_size0=item_size1key+item_size1val;
27969  size_t nbytes=total_item_size0*buf.len;
27970  buf.p=new char[nbytes];
27971  unsigned int count0=0;
27972  std::map<std::string, bool>::const_iterator it0=x.begin();
27973  for(;it0!=x.end();++it0){
27974  hasher_.Clear();
27975  hasher_.Update(it0->first);
27976  Digest key1key = hasher_.digest();
27977  hid_t keysds1key = VLDataset(VL_STRING, true);
27978  hid_t valsds1key = VLDataset(VL_STRING, false);
27979  if (vlkeys_[VL_STRING].count(key1key) != 1) {
27980  AppendVLKey(keysds1key, VL_STRING, key1key);
27981  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
27982  }
27983  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
27984  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
27985  ++count0;
27986 
27987  }
27988  return buf;
27989 }
27990 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, int>& x) {
27991  hvl_t buf;
27992  buf.len=x.size();
27993  size_t item_size1key=CYCLUS_SHA1_SIZE;
27994  size_t item_size1val=sizeof(int);
27995  size_t total_item_size0=item_size1key+item_size1val;
27996  size_t nbytes=total_item_size0*buf.len;
27997  buf.p=new char[nbytes];
27998  unsigned int count0=0;
27999  std::map<std::string, int>::const_iterator it0=x.begin();
28000  for(;it0!=x.end();++it0){
28001  hasher_.Clear();
28002  hasher_.Update(it0->first);
28003  Digest key1key = hasher_.digest();
28004  hid_t keysds1key = VLDataset(VL_STRING, true);
28005  hid_t valsds1key = VLDataset(VL_STRING, false);
28006  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28007  AppendVLKey(keysds1key, VL_STRING, key1key);
28008  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28009  }
28010  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28011  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28012  ++count0;
28013 
28014  }
28015  return buf;
28016 }
28017 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, float>& x) {
28018  hvl_t buf;
28019  buf.len=x.size();
28020  size_t item_size1key=CYCLUS_SHA1_SIZE;
28021  size_t item_size1val=sizeof(float);
28022  size_t total_item_size0=item_size1key+item_size1val;
28023  size_t nbytes=total_item_size0*buf.len;
28024  buf.p=new char[nbytes];
28025  unsigned int count0=0;
28026  std::map<std::string, float>::const_iterator it0=x.begin();
28027  for(;it0!=x.end();++it0){
28028  hasher_.Clear();
28029  hasher_.Update(it0->first);
28030  Digest key1key = hasher_.digest();
28031  hid_t keysds1key = VLDataset(VL_STRING, true);
28032  hid_t valsds1key = VLDataset(VL_STRING, false);
28033  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28034  AppendVLKey(keysds1key, VL_STRING, key1key);
28035  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28036  }
28037  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28038  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28039  ++count0;
28040 
28041  }
28042  return buf;
28043 }
28044 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, double>& x) {
28045  hvl_t buf;
28046  buf.len=x.size();
28047  size_t item_size1key=CYCLUS_SHA1_SIZE;
28048  size_t item_size1val=sizeof(double);
28049  size_t total_item_size0=item_size1key+item_size1val;
28050  size_t nbytes=total_item_size0*buf.len;
28051  buf.p=new char[nbytes];
28052  unsigned int count0=0;
28053  std::map<std::string, double>::const_iterator it0=x.begin();
28054  for(;it0!=x.end();++it0){
28055  hasher_.Clear();
28056  hasher_.Update(it0->first);
28057  Digest key1key = hasher_.digest();
28058  hid_t keysds1key = VLDataset(VL_STRING, true);
28059  hid_t valsds1key = VLDataset(VL_STRING, false);
28060  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28061  AppendVLKey(keysds1key, VL_STRING, key1key);
28062  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28063  }
28064  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28065  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28066  ++count0;
28067 
28068  }
28069  return buf;
28070 }
28071 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::string>& x) {
28072  hvl_t buf;
28073  buf.len=x.size();
28074  size_t item_size1key=CYCLUS_SHA1_SIZE;
28075  size_t item_size1val=CYCLUS_SHA1_SIZE;
28076  size_t total_item_size0=item_size1key+item_size1val;
28077  size_t nbytes=total_item_size0*buf.len;
28078  buf.p=new char[nbytes];
28079  unsigned int count0=0;
28080  std::map<std::string, std::string>::const_iterator it0=x.begin();
28081  for(;it0!=x.end();++it0){
28082  hasher_.Clear();
28083  hasher_.Update(it0->first);
28084  Digest key1key = hasher_.digest();
28085  hid_t keysds1key = VLDataset(VL_STRING, true);
28086  hid_t valsds1key = VLDataset(VL_STRING, false);
28087  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28088  AppendVLKey(keysds1key, VL_STRING, key1key);
28089  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28090  }
28091  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28092  hasher_.Clear();
28093  hasher_.Update(it0->second);
28094  Digest key1val = hasher_.digest();
28095  hid_t keysds1val = VLDataset(VL_STRING, true);
28096  hid_t valsds1val = VLDataset(VL_STRING, false);
28097  if (vlkeys_[VL_STRING].count(key1val) != 1) {
28098  AppendVLKey(keysds1val, VL_STRING, key1val);
28099  InsertVLVal(valsds1val, VL_STRING, key1val, it0->second);
28100  }
28101  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
28102  ++count0;
28103 
28104  }
28105  return buf;
28106 }
28107 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, cyclus::Blob>& x) {
28108  hvl_t buf;
28109  buf.len=x.size();
28110  size_t item_size1key=CYCLUS_SHA1_SIZE;
28111  size_t item_size1val=CYCLUS_SHA1_SIZE;
28112  size_t total_item_size0=item_size1key+item_size1val;
28113  size_t nbytes=total_item_size0*buf.len;
28114  buf.p=new char[nbytes];
28115  unsigned int count0=0;
28116  std::map<std::string, cyclus::Blob>::const_iterator it0=x.begin();
28117  for(;it0!=x.end();++it0){
28118  hasher_.Clear();
28119  hasher_.Update(it0->first);
28120  Digest key1key = hasher_.digest();
28121  hid_t keysds1key = VLDataset(VL_STRING, true);
28122  hid_t valsds1key = VLDataset(VL_STRING, false);
28123  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28124  AppendVLKey(keysds1key, VL_STRING, key1key);
28125  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28126  }
28127  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28128  hasher_.Clear();
28129  hasher_.Update(it0->second);
28130  Digest key1val = hasher_.digest();
28131  hid_t keysds1val = VLDataset(BLOB, true);
28132  hid_t valsds1val = VLDataset(BLOB, false);
28133  if (vlkeys_[BLOB].count(key1val) != 1) {
28134  AppendVLKey(keysds1val, BLOB, key1val);
28135  InsertVLVal(valsds1val, BLOB, key1val, (it0->second).str());
28136  }
28137  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
28138  ++count0;
28139 
28140  }
28141  return buf;
28142 }
28143 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, boost::uuids::uuid>& x) {
28144  hvl_t buf;
28145  buf.len=x.size();
28146  size_t item_size1key=CYCLUS_SHA1_SIZE;
28147  size_t item_size1val=CYCLUS_UUID_SIZE;
28148  size_t total_item_size0=item_size1key+item_size1val;
28149  size_t nbytes=total_item_size0*buf.len;
28150  buf.p=new char[nbytes];
28151  unsigned int count0=0;
28152  std::map<std::string, boost::uuids::uuid>::const_iterator it0=x.begin();
28153  for(;it0!=x.end();++it0){
28154  hasher_.Clear();
28155  hasher_.Update(it0->first);
28156  Digest key1key = hasher_.digest();
28157  hid_t keysds1key = VLDataset(VL_STRING, true);
28158  hid_t valsds1key = VLDataset(VL_STRING, false);
28159  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28160  AppendVLKey(keysds1key, VL_STRING, key1key);
28161  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28162  }
28163  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28164  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28165  ++count0;
28166 
28167  }
28168  return buf;
28169 }
28170 hvl_t Hdf5Back::VLValToBuf(const std::map<std::pair<int, std::string>, double>& x) {
28171  hvl_t buf;
28172  buf.len=x.size();
28173  size_t item_size2keyfirst=sizeof(int);
28174  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
28175  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
28176  size_t item_size1key=total_item_size1key;
28177  size_t item_size1val=sizeof(double);
28178  size_t total_item_size0=item_size1key+item_size1val;
28179  size_t nbytes=total_item_size0*buf.len;
28180  buf.p=new char[nbytes];
28181  unsigned int count0=0;
28182  std::map<std::pair<int, std::string>, double>::const_iterator it0=x.begin();
28183  for(;it0!=x.end();++it0){
28184  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first.first), item_size2keyfirst);
28185  hasher_.Clear();
28186  hasher_.Update(it0->first.second);
28187  Digest key2keysecond = hasher_.digest();
28188  hid_t keysds2keysecond = VLDataset(VL_STRING, true);
28189  hid_t valsds2keysecond = VLDataset(VL_STRING, false);
28190  if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
28191  AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
28192  InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
28193  }
28194  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2keyfirst, key2keysecond.val, item_size2keysecond);
28195  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28196  ++count0;
28197 
28198  }
28199  return buf;
28200 }
28201 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::vector<double>>& x) {
28202  hvl_t buf;
28203  buf.len=x.size();
28204  size_t item_size1key=CYCLUS_SHA1_SIZE;
28205  size_t item_size1val=CYCLUS_SHA1_SIZE;
28206  size_t total_item_size0=item_size1key+item_size1val;
28207  size_t nbytes=total_item_size0*buf.len;
28208  buf.p=new char[nbytes];
28209  unsigned int count0=0;
28210  std::map<std::string, std::vector<double>>::const_iterator it0=x.begin();
28211  for(;it0!=x.end();++it0){
28212  hasher_.Clear();
28213  hasher_.Update(it0->first);
28214  Digest key1key = hasher_.digest();
28215  hid_t keysds1key = VLDataset(VL_STRING, true);
28216  hid_t valsds1key = VLDataset(VL_STRING, false);
28217  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28218  AppendVLKey(keysds1key, VL_STRING, key1key);
28219  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28220  }
28221  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28222  hasher_.Clear();
28223  hasher_.Update(it0->second);
28224  Digest key1val = hasher_.digest();
28225  hid_t keysds1val = VLDataset(VL_VECTOR_DOUBLE, true);
28226  hid_t valsds1val = VLDataset(VL_VECTOR_DOUBLE, false);
28227  if (vlkeys_[VL_VECTOR_DOUBLE].count(key1val) != 1) {
28228  hvl_t buf1val = VLValToBuf(it0->second);
28229  AppendVLKey(keysds1val, VL_VECTOR_DOUBLE, key1val);
28230  InsertVLVal(valsds1val, VL_VECTOR_DOUBLE, key1val, buf1val);
28231  }
28232  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
28233  ++count0;
28234 
28235  }
28236  return buf;
28237 }
28238 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::map<int, double>>& x) {
28239  hvl_t buf;
28240  buf.len=x.size();
28241  size_t item_size1key=CYCLUS_SHA1_SIZE;
28242  size_t item_size1val=CYCLUS_SHA1_SIZE;
28243  size_t total_item_size0=item_size1key+item_size1val;
28244  size_t nbytes=total_item_size0*buf.len;
28245  buf.p=new char[nbytes];
28246  unsigned int count0=0;
28247  std::map<std::string, std::map<int, double>>::const_iterator it0=x.begin();
28248  for(;it0!=x.end();++it0){
28249  hasher_.Clear();
28250  hasher_.Update(it0->first);
28251  Digest key1key = hasher_.digest();
28252  hid_t keysds1key = VLDataset(VL_STRING, true);
28253  hid_t valsds1key = VLDataset(VL_STRING, false);
28254  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28255  AppendVLKey(keysds1key, VL_STRING, key1key);
28256  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28257  }
28258  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28259  hasher_.Clear();
28260  hasher_.Update(it0->second);
28261  Digest key1val = hasher_.digest();
28262  hid_t keysds1val = VLDataset(VL_MAP_INT_DOUBLE, true);
28263  hid_t valsds1val = VLDataset(VL_MAP_INT_DOUBLE, false);
28264  if (vlkeys_[VL_MAP_INT_DOUBLE].count(key1val) != 1) {
28265  hvl_t buf1val = VLValToBuf(it0->second);
28266  AppendVLKey(keysds1val, VL_MAP_INT_DOUBLE, key1val);
28267  InsertVLVal(valsds1val, VL_MAP_INT_DOUBLE, key1val, buf1val);
28268  }
28269  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
28270  ++count0;
28271 
28272  }
28273  return buf;
28274 }
28275 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::pair<double, std::map<int, double>>>& x) {
28276  hvl_t buf;
28277  buf.len=x.size();
28278  size_t item_size2valfirst=sizeof(double);
28279  size_t item_size2valsecond=CYCLUS_SHA1_SIZE;
28280  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
28281  size_t item_size1key=CYCLUS_SHA1_SIZE;
28282  size_t item_size1val=total_item_size1val;
28283  size_t total_item_size0=item_size1key+item_size1val;
28284  size_t nbytes=total_item_size0*buf.len;
28285  buf.p=new char[nbytes];
28286  unsigned int count0=0;
28287  std::map<std::string, std::pair<double, std::map<int, double>>>::const_iterator it0=x.begin();
28288  for(;it0!=x.end();++it0){
28289  hasher_.Clear();
28290  hasher_.Update(it0->first);
28291  Digest key1key = hasher_.digest();
28292  hid_t keysds1key = VLDataset(VL_STRING, true);
28293  hid_t valsds1key = VLDataset(VL_STRING, false);
28294  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28295  AppendVLKey(keysds1key, VL_STRING, key1key);
28296  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28297  }
28298  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28299  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second.first), item_size2valfirst);
28300  hasher_.Clear();
28301  hasher_.Update(it0->second.second);
28302  Digest key2valsecond = hasher_.digest();
28303  hid_t keysds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, true);
28304  hid_t valsds2valsecond = VLDataset(VL_MAP_INT_DOUBLE, false);
28305  if (vlkeys_[VL_MAP_INT_DOUBLE].count(key2valsecond) != 1) {
28306  hvl_t buf2valsecond = VLValToBuf(it0->second.second);
28307  AppendVLKey(keysds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond);
28308  InsertVLVal(valsds2valsecond, VL_MAP_INT_DOUBLE, key2valsecond, buf2valsecond);
28309  }
28310  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key+item_size2valfirst, key2valsecond.val, item_size2valsecond);
28311  ++count0;
28312 
28313  }
28314  return buf;
28315 }
28316 hvl_t Hdf5Back::VLValToBuf(const std::map<int, std::map<std::string, double>>& x) {
28317  hvl_t buf;
28318  buf.len=x.size();
28319  size_t item_size1key=sizeof(int);
28320  size_t item_size1val=CYCLUS_SHA1_SIZE;
28321  size_t total_item_size0=item_size1key+item_size1val;
28322  size_t nbytes=total_item_size0*buf.len;
28323  buf.p=new char[nbytes];
28324  unsigned int count0=0;
28325  std::map<int, std::map<std::string, double>>::const_iterator it0=x.begin();
28326  for(;it0!=x.end();++it0){
28327  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &(it0->first), item_size1key);
28328  hasher_.Clear();
28329  hasher_.Update(it0->second);
28330  Digest key1val = hasher_.digest();
28331  hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
28332  hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
28333  if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
28334  hvl_t buf1val = VLValToBuf(it0->second);
28335  AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
28336  InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
28337  }
28338  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
28339  ++count0;
28340 
28341  }
28342  return buf;
28343 }
28344 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>& x) {
28345  hvl_t buf;
28346  buf.len=x.size();
28347  size_t item_size1key=CYCLUS_SHA1_SIZE;
28348  size_t item_size1val=CYCLUS_SHA1_SIZE;
28349  size_t total_item_size0=item_size1key+item_size1val;
28350  size_t nbytes=total_item_size0*buf.len;
28351  buf.p=new char[nbytes];
28352  unsigned int count0=0;
28353  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>::const_iterator it0=x.begin();
28354  for(;it0!=x.end();++it0){
28355  hasher_.Clear();
28356  hasher_.Update(it0->first);
28357  Digest key1key = hasher_.digest();
28358  hid_t keysds1key = VLDataset(VL_STRING, true);
28359  hid_t valsds1key = VLDataset(VL_STRING, false);
28360  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28361  AppendVLKey(keysds1key, VL_STRING, key1key);
28362  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28363  }
28364  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28365  hasher_.Clear();
28366  hasher_.Update(it0->second);
28367  Digest key1val = hasher_.digest();
28368  hid_t keysds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, true);
28369  hid_t valsds1val = VLDataset(VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, false);
28370  if (vlkeys_[VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING].count(key1val) != 1) {
28371  hvl_t buf1val = VLValToBuf(it0->second);
28372  AppendVLKey(keysds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val);
28373  InsertVLVal(valsds1val, VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING, key1val, buf1val);
28374  }
28375  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
28376  ++count0;
28377 
28378  }
28379  return buf;
28380 }
28381 hvl_t Hdf5Back::VLValToBuf(const std::list<std::pair<int, int>>& x) {
28382  hvl_t buf;
28383  buf.len=x.size();
28384  size_t item_size2elemfirst=sizeof(int);
28385  size_t item_size2elemsecond=sizeof(int);
28386  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
28387  size_t item_size1elem=total_item_size1elem;
28388  size_t total_item_size0=item_size1elem;
28389  size_t nbytes=total_item_size0*buf.len;
28390  buf.p=new char[nbytes];
28391  unsigned int count0=0;
28392  std::list<std::pair<int, int>>::const_iterator it0=x.begin();
28393  for(;it0!=x.end();++it0){
28394  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0).first), item_size2elemfirst);
28395  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2elemfirst, &((*it0).second), item_size2elemsecond);
28396  ++count0;
28397 
28398  }
28399  return buf;
28400 }
28401 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::pair<std::string, std::vector<double>>>& x) {
28402  hvl_t buf;
28403  buf.len=x.size();
28404  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
28405  size_t item_size2valsecond=CYCLUS_SHA1_SIZE;
28406  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
28407  size_t item_size1key=CYCLUS_SHA1_SIZE;
28408  size_t item_size1val=total_item_size1val;
28409  size_t total_item_size0=item_size1key+item_size1val;
28410  size_t nbytes=total_item_size0*buf.len;
28411  buf.p=new char[nbytes];
28412  unsigned int count0=0;
28413  std::map<std::string, std::pair<std::string, std::vector<double>>>::const_iterator it0=x.begin();
28414  for(;it0!=x.end();++it0){
28415  hasher_.Clear();
28416  hasher_.Update(it0->first);
28417  Digest key1key = hasher_.digest();
28418  hid_t keysds1key = VLDataset(VL_STRING, true);
28419  hid_t valsds1key = VLDataset(VL_STRING, false);
28420  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28421  AppendVLKey(keysds1key, VL_STRING, key1key);
28422  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28423  }
28424  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28425  hasher_.Clear();
28426  hasher_.Update(it0->second.first);
28427  Digest key2valfirst = hasher_.digest();
28428  hid_t keysds2valfirst = VLDataset(VL_STRING, true);
28429  hid_t valsds2valfirst = VLDataset(VL_STRING, false);
28430  if (vlkeys_[VL_STRING].count(key2valfirst) != 1) {
28431  AppendVLKey(keysds2valfirst, VL_STRING, key2valfirst);
28432  InsertVLVal(valsds2valfirst, VL_STRING, key2valfirst, it0->second.first);
28433  }
28434  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key2valfirst.val, item_size2valfirst);
28435  hasher_.Clear();
28436  hasher_.Update(it0->second.second);
28437  Digest key2valsecond = hasher_.digest();
28438  hid_t keysds2valsecond = VLDataset(VL_VECTOR_DOUBLE, true);
28439  hid_t valsds2valsecond = VLDataset(VL_VECTOR_DOUBLE, false);
28440  if (vlkeys_[VL_VECTOR_DOUBLE].count(key2valsecond) != 1) {
28441  hvl_t buf2valsecond = VLValToBuf(it0->second.second);
28442  AppendVLKey(keysds2valsecond, VL_VECTOR_DOUBLE, key2valsecond);
28443  InsertVLVal(valsds2valsecond, VL_VECTOR_DOUBLE, key2valsecond, buf2valsecond);
28444  }
28445  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key+item_size2valfirst, key2valsecond.val, item_size2valsecond);
28446  ++count0;
28447 
28448  }
28449  return buf;
28450 }
28451 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::map<std::string, int>>& x) {
28452  hvl_t buf;
28453  buf.len=x.size();
28454  size_t item_size1key=CYCLUS_SHA1_SIZE;
28455  size_t item_size1val=CYCLUS_SHA1_SIZE;
28456  size_t total_item_size0=item_size1key+item_size1val;
28457  size_t nbytes=total_item_size0*buf.len;
28458  buf.p=new char[nbytes];
28459  unsigned int count0=0;
28460  std::map<std::string, std::map<std::string, int>>::const_iterator it0=x.begin();
28461  for(;it0!=x.end();++it0){
28462  hasher_.Clear();
28463  hasher_.Update(it0->first);
28464  Digest key1key = hasher_.digest();
28465  hid_t keysds1key = VLDataset(VL_STRING, true);
28466  hid_t valsds1key = VLDataset(VL_STRING, false);
28467  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28468  AppendVLKey(keysds1key, VL_STRING, key1key);
28469  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28470  }
28471  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28472  hasher_.Clear();
28473  hasher_.Update(it0->second);
28474  Digest key1val = hasher_.digest();
28475  hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_INT, true);
28476  hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_INT, false);
28477  if (vlkeys_[VL_MAP_VL_STRING_INT].count(key1val) != 1) {
28478  hvl_t buf1val = VLValToBuf(it0->second);
28479  AppendVLKey(keysds1val, VL_MAP_VL_STRING_INT, key1val);
28480  InsertVLVal(valsds1val, VL_MAP_VL_STRING_INT, key1val, buf1val);
28481  }
28482  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
28483  ++count0;
28484 
28485  }
28486  return buf;
28487 }
28488 hvl_t Hdf5Back::VLValToBuf(const std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>& x) {
28489  hvl_t buf;
28490  buf.len=x.size();
28491  size_t item_size3elemfirstfirst=sizeof(double);
28492  size_t item_size3elemfirstsecond=sizeof(double);
28493  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
28494  size_t item_size2elemfirst=total_item_size2elemfirst;
28495  size_t item_size2elemsecond=CYCLUS_SHA1_SIZE;
28496  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
28497  size_t item_size1elem=total_item_size1elem;
28498  size_t total_item_size0=item_size1elem;
28499  size_t nbytes=total_item_size0*buf.len;
28500  buf.p=new char[nbytes];
28501  unsigned int count0=0;
28502  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>::const_iterator it0=x.begin();
28503  for(;it0!=x.end();++it0){
28504  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0).first.first), item_size3elemfirstfirst);
28505  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size3elemfirstfirst, &((*it0).first.second), item_size3elemfirstsecond);
28506  hasher_.Clear();
28507  hasher_.Update((*it0).second);
28508  Digest key2elemsecond = hasher_.digest();
28509  hid_t keysds2elemsecond = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
28510  hid_t valsds2elemsecond = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
28511  if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key2elemsecond) != 1) {
28512  hvl_t buf2elemsecond = VLValToBuf((*it0).second);
28513  AppendVLKey(keysds2elemsecond, VL_MAP_VL_STRING_DOUBLE, key2elemsecond);
28514  InsertVLVal(valsds2elemsecond, VL_MAP_VL_STRING_DOUBLE, key2elemsecond, buf2elemsecond);
28515  }
28516  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2elemfirst, key2elemsecond.val, item_size2elemsecond);
28517  ++count0;
28518 
28519  }
28520  return buf;
28521 }
28522 hvl_t Hdf5Back::VLValToBuf(const std::vector<std::pair<int, std::pair<std::string, std::string>>>& x) {
28523  hvl_t buf;
28524  buf.len=x.size();
28525  size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
28526  size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
28527  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
28528  size_t item_size2elemfirst=sizeof(int);
28529  size_t item_size2elemsecond=total_item_size2elemsecond;
28530  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
28531  size_t item_size1elem=total_item_size1elem;
28532  size_t total_item_size0=item_size1elem;
28533  size_t nbytes=total_item_size0*buf.len;
28534  buf.p=new char[nbytes];
28535  unsigned int count0=0;
28536  std::vector<std::pair<int, std::pair<std::string, std::string>>>::const_iterator it0=x.begin();
28537  for(;it0!=x.end();++it0){
28538  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), &((*it0).first), item_size2elemfirst);
28539  hasher_.Clear();
28540  hasher_.Update((*it0).second.first);
28541  Digest key3elemsecondfirst = hasher_.digest();
28542  hid_t keysds3elemsecondfirst = VLDataset(VL_STRING, true);
28543  hid_t valsds3elemsecondfirst = VLDataset(VL_STRING, false);
28544  if (vlkeys_[VL_STRING].count(key3elemsecondfirst) != 1) {
28545  AppendVLKey(keysds3elemsecondfirst, VL_STRING, key3elemsecondfirst);
28546  InsertVLVal(valsds3elemsecondfirst, VL_STRING, key3elemsecondfirst, (*it0).second.first);
28547  }
28548  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2elemfirst, key3elemsecondfirst.val, item_size3elemsecondfirst);
28549  hasher_.Clear();
28550  hasher_.Update((*it0).second.second);
28551  Digest key3elemsecondsecond = hasher_.digest();
28552  hid_t keysds3elemsecondsecond = VLDataset(VL_STRING, true);
28553  hid_t valsds3elemsecondsecond = VLDataset(VL_STRING, false);
28554  if (vlkeys_[VL_STRING].count(key3elemsecondsecond) != 1) {
28555  AppendVLKey(keysds3elemsecondsecond, VL_STRING, key3elemsecondsecond);
28556  InsertVLVal(valsds3elemsecondsecond, VL_STRING, key3elemsecondsecond, (*it0).second.second);
28557  }
28558  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2elemfirst+item_size3elemsecondfirst, key3elemsecondsecond.val, item_size3elemsecondsecond);
28559  ++count0;
28560 
28561  }
28562  return buf;
28563 }
28564 hvl_t Hdf5Back::VLValToBuf(const std::map<std::pair<std::string, std::string>, int>& x) {
28565  hvl_t buf;
28566  buf.len=x.size();
28567  size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
28568  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
28569  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
28570  size_t item_size1key=total_item_size1key;
28571  size_t item_size1val=sizeof(int);
28572  size_t total_item_size0=item_size1key+item_size1val;
28573  size_t nbytes=total_item_size0*buf.len;
28574  buf.p=new char[nbytes];
28575  unsigned int count0=0;
28576  std::map<std::pair<std::string, std::string>, int>::const_iterator it0=x.begin();
28577  for(;it0!=x.end();++it0){
28578  hasher_.Clear();
28579  hasher_.Update(it0->first.first);
28580  Digest key2keyfirst = hasher_.digest();
28581  hid_t keysds2keyfirst = VLDataset(VL_STRING, true);
28582  hid_t valsds2keyfirst = VLDataset(VL_STRING, false);
28583  if (vlkeys_[VL_STRING].count(key2keyfirst) != 1) {
28584  AppendVLKey(keysds2keyfirst, VL_STRING, key2keyfirst);
28585  InsertVLVal(valsds2keyfirst, VL_STRING, key2keyfirst, it0->first.first);
28586  }
28587  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key2keyfirst.val, item_size2keyfirst);
28588  hasher_.Clear();
28589  hasher_.Update(it0->first.second);
28590  Digest key2keysecond = hasher_.digest();
28591  hid_t keysds2keysecond = VLDataset(VL_STRING, true);
28592  hid_t valsds2keysecond = VLDataset(VL_STRING, false);
28593  if (vlkeys_[VL_STRING].count(key2keysecond) != 1) {
28594  AppendVLKey(keysds2keysecond, VL_STRING, key2keysecond);
28595  InsertVLVal(valsds2keysecond, VL_STRING, key2keysecond, it0->first.second);
28596  }
28597  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size2keyfirst, key2keysecond.val, item_size2keysecond);
28598  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, &(it0->second), item_size1val);
28599  ++count0;
28600 
28601  }
28602  return buf;
28603 }
28604 hvl_t Hdf5Back::VLValToBuf(const std::map<std::string, std::map<std::string, double>>& x) {
28605  hvl_t buf;
28606  buf.len=x.size();
28607  size_t item_size1key=CYCLUS_SHA1_SIZE;
28608  size_t item_size1val=CYCLUS_SHA1_SIZE;
28609  size_t total_item_size0=item_size1key+item_size1val;
28610  size_t nbytes=total_item_size0*buf.len;
28611  buf.p=new char[nbytes];
28612  unsigned int count0=0;
28613  std::map<std::string, std::map<std::string, double>>::const_iterator it0=x.begin();
28614  for(;it0!=x.end();++it0){
28615  hasher_.Clear();
28616  hasher_.Update(it0->first);
28617  Digest key1key = hasher_.digest();
28618  hid_t keysds1key = VLDataset(VL_STRING, true);
28619  hid_t valsds1key = VLDataset(VL_STRING, false);
28620  if (vlkeys_[VL_STRING].count(key1key) != 1) {
28621  AppendVLKey(keysds1key, VL_STRING, key1key);
28622  InsertVLVal(valsds1key, VL_STRING, key1key, it0->first);
28623  }
28624  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0), key1key.val, item_size1key);
28625  hasher_.Clear();
28626  hasher_.Update(it0->second);
28627  Digest key1val = hasher_.digest();
28628  hid_t keysds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, true);
28629  hid_t valsds1val = VLDataset(VL_MAP_VL_STRING_DOUBLE, false);
28630  if (vlkeys_[VL_MAP_VL_STRING_DOUBLE].count(key1val) != 1) {
28631  hvl_t buf1val = VLValToBuf(it0->second);
28632  AppendVLKey(keysds1val, VL_MAP_VL_STRING_DOUBLE, key1val);
28633  InsertVLVal(valsds1val, VL_MAP_VL_STRING_DOUBLE, key1val, buf1val);
28634  }
28635  memcpy(reinterpret_cast<char*>(buf.p)+(total_item_size0*count0)+item_size1key, key1val.val, item_size1val);
28636  ++count0;
28637 
28638  }
28639  return buf;
28640 }
28641 
28642 
28643 
28644 template<>
28645 std::vector<int> Hdf5Back::VLBufToVal<std::vector<int>>(const hvl_t& buf) {
28646  std::vector<int> x0;
28647  char* p=reinterpret_cast<char*>(buf.p);
28648  size_t item_size1elem=sizeof(int);
28649  size_t total_item_size0=item_size1elem;
28650  unsigned int count0=0;
28651  for(;count0<buf.len;++count0){
28652  int x1elem=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28653  x0.push_back(x1elem);
28654 
28655  }
28656  return x0;
28657 }
28658 template<>
28659 std::vector<float> Hdf5Back::VLBufToVal<std::vector<float>>(const hvl_t& buf) {
28660  std::vector<float> x0;
28661  char* p=reinterpret_cast<char*>(buf.p);
28662  size_t item_size1elem=sizeof(float);
28663  size_t total_item_size0=item_size1elem;
28664  unsigned int count0=0;
28665  for(;count0<buf.len;++count0){
28666  float x1elem=*reinterpret_cast<float*>(p+(total_item_size0*count0));
28667  x0.push_back(x1elem);
28668 
28669  }
28670  return x0;
28671 }
28672 template<>
28673 std::vector<double> Hdf5Back::VLBufToVal<std::vector<double>>(const hvl_t& buf) {
28674  std::vector<double> x0;
28675  char* p=reinterpret_cast<char*>(buf.p);
28676  size_t item_size1elem=sizeof(double);
28677  size_t total_item_size0=item_size1elem;
28678  unsigned int count0=0;
28679  for(;count0<buf.len;++count0){
28680  double x1elem=*reinterpret_cast<double*>(p+(total_item_size0*count0));
28681  x0.push_back(x1elem);
28682 
28683  }
28684  return x0;
28685 }
28686 template<>
28687 std::vector<std::string> Hdf5Back::VLBufToVal<std::vector<std::string>>(const hvl_t& buf) {
28688  std::vector<std::string> x0;
28689  char* p=reinterpret_cast<char*>(buf.p);
28690  size_t item_size1elem=CYCLUS_SHA1_SIZE;
28691  size_t total_item_size0=item_size1elem;
28692  unsigned int count0=0;
28693  for(;count0<buf.len;++count0){
28694  std::string x1elem=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
28695  x0.push_back(x1elem);
28696 
28697  }
28698  return x0;
28699 }
28700 template<>
28701 std::vector<cyclus::Blob> Hdf5Back::VLBufToVal<std::vector<cyclus::Blob>>(const hvl_t& buf) {
28702  std::vector<cyclus::Blob> x0;
28703  char* p=reinterpret_cast<char*>(buf.p);
28704  size_t item_size1elem=CYCLUS_SHA1_SIZE;
28705  size_t total_item_size0=item_size1elem;
28706  unsigned int count0=0;
28707  for(;count0<buf.len;++count0){
28708  cyclus::Blob x1elem=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0));
28709  x0.push_back(x1elem);
28710 
28711  }
28712  return x0;
28713 }
28714 template<>
28715 std::vector<boost::uuids::uuid> Hdf5Back::VLBufToVal<std::vector<boost::uuids::uuid>>(const hvl_t& buf) {
28716  std::vector<boost::uuids::uuid> x0;
28717  char* p=reinterpret_cast<char*>(buf.p);
28718  size_t item_size1elem=CYCLUS_UUID_SIZE;
28719  size_t total_item_size0=item_size1elem;
28720  unsigned int count0=0;
28721  for(;count0<buf.len;++count0){
28722  boost::uuids::uuid x1elem=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0));
28723  x0.push_back(x1elem);
28724 
28725  }
28726  return x0;
28727 }
28728 template<>
28729 std::set<int> Hdf5Back::VLBufToVal<std::set<int>>(const hvl_t& buf) {
28730  std::set<int> x0;
28731  char* p=reinterpret_cast<char*>(buf.p);
28732  size_t item_size1elem=sizeof(int);
28733  size_t total_item_size0=item_size1elem;
28734  unsigned int count0=0;
28735  for(;count0<buf.len;++count0){
28736  int x1elem=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28737  x0.insert(x1elem);
28738 
28739  }
28740  return x0;
28741 }
28742 template<>
28743 std::set<float> Hdf5Back::VLBufToVal<std::set<float>>(const hvl_t& buf) {
28744  std::set<float> x0;
28745  char* p=reinterpret_cast<char*>(buf.p);
28746  size_t item_size1elem=sizeof(float);
28747  size_t total_item_size0=item_size1elem;
28748  unsigned int count0=0;
28749  for(;count0<buf.len;++count0){
28750  float x1elem=*reinterpret_cast<float*>(p+(total_item_size0*count0));
28751  x0.insert(x1elem);
28752 
28753  }
28754  return x0;
28755 }
28756 template<>
28757 std::set<double> Hdf5Back::VLBufToVal<std::set<double>>(const hvl_t& buf) {
28758  std::set<double> x0;
28759  char* p=reinterpret_cast<char*>(buf.p);
28760  size_t item_size1elem=sizeof(double);
28761  size_t total_item_size0=item_size1elem;
28762  unsigned int count0=0;
28763  for(;count0<buf.len;++count0){
28764  double x1elem=*reinterpret_cast<double*>(p+(total_item_size0*count0));
28765  x0.insert(x1elem);
28766 
28767  }
28768  return x0;
28769 }
28770 template<>
28771 std::set<std::string> Hdf5Back::VLBufToVal<std::set<std::string>>(const hvl_t& buf) {
28772  std::set<std::string> x0;
28773  char* p=reinterpret_cast<char*>(buf.p);
28774  size_t item_size1elem=CYCLUS_SHA1_SIZE;
28775  size_t total_item_size0=item_size1elem;
28776  unsigned int count0=0;
28777  for(;count0<buf.len;++count0){
28778  std::string x1elem=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
28779  x0.insert(x1elem);
28780 
28781  }
28782  return x0;
28783 }
28784 template<>
28785 std::set<cyclus::Blob> Hdf5Back::VLBufToVal<std::set<cyclus::Blob>>(const hvl_t& buf) {
28786  std::set<cyclus::Blob> x0;
28787  char* p=reinterpret_cast<char*>(buf.p);
28788  size_t item_size1elem=CYCLUS_SHA1_SIZE;
28789  size_t total_item_size0=item_size1elem;
28790  unsigned int count0=0;
28791  for(;count0<buf.len;++count0){
28792  cyclus::Blob x1elem=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0));
28793  x0.insert(x1elem);
28794 
28795  }
28796  return x0;
28797 }
28798 template<>
28799 std::set<boost::uuids::uuid> Hdf5Back::VLBufToVal<std::set<boost::uuids::uuid>>(const hvl_t& buf) {
28800  std::set<boost::uuids::uuid> x0;
28801  char* p=reinterpret_cast<char*>(buf.p);
28802  size_t item_size1elem=CYCLUS_UUID_SIZE;
28803  size_t total_item_size0=item_size1elem;
28804  unsigned int count0=0;
28805  for(;count0<buf.len;++count0){
28806  boost::uuids::uuid x1elem=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0));
28807  x0.insert(x1elem);
28808 
28809  }
28810  return x0;
28811 }
28812 template<>
28813 std::list<bool> Hdf5Back::VLBufToVal<std::list<bool>>(const hvl_t& buf) {
28814  std::list<bool> x0;
28815  char* p=reinterpret_cast<char*>(buf.p);
28816  size_t item_size1elem=sizeof(char);
28817  size_t total_item_size0=item_size1elem;
28818  unsigned int count0=0;
28819  for(;count0<buf.len;++count0){
28820  bool x1elem=*reinterpret_cast<bool*>(p+(total_item_size0*count0));
28821  x0.push_back(x1elem);
28822 
28823  }
28824  return x0;
28825 }
28826 template<>
28827 std::list<int> Hdf5Back::VLBufToVal<std::list<int>>(const hvl_t& buf) {
28828  std::list<int> x0;
28829  char* p=reinterpret_cast<char*>(buf.p);
28830  size_t item_size1elem=sizeof(int);
28831  size_t total_item_size0=item_size1elem;
28832  unsigned int count0=0;
28833  for(;count0<buf.len;++count0){
28834  int x1elem=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28835  x0.push_back(x1elem);
28836 
28837  }
28838  return x0;
28839 }
28840 template<>
28841 std::list<float> Hdf5Back::VLBufToVal<std::list<float>>(const hvl_t& buf) {
28842  std::list<float> x0;
28843  char* p=reinterpret_cast<char*>(buf.p);
28844  size_t item_size1elem=sizeof(float);
28845  size_t total_item_size0=item_size1elem;
28846  unsigned int count0=0;
28847  for(;count0<buf.len;++count0){
28848  float x1elem=*reinterpret_cast<float*>(p+(total_item_size0*count0));
28849  x0.push_back(x1elem);
28850 
28851  }
28852  return x0;
28853 }
28854 template<>
28855 std::list<double> Hdf5Back::VLBufToVal<std::list<double>>(const hvl_t& buf) {
28856  std::list<double> x0;
28857  char* p=reinterpret_cast<char*>(buf.p);
28858  size_t item_size1elem=sizeof(double);
28859  size_t total_item_size0=item_size1elem;
28860  unsigned int count0=0;
28861  for(;count0<buf.len;++count0){
28862  double x1elem=*reinterpret_cast<double*>(p+(total_item_size0*count0));
28863  x0.push_back(x1elem);
28864 
28865  }
28866  return x0;
28867 }
28868 template<>
28869 std::list<std::string> Hdf5Back::VLBufToVal<std::list<std::string>>(const hvl_t& buf) {
28870  std::list<std::string> x0;
28871  char* p=reinterpret_cast<char*>(buf.p);
28872  size_t item_size1elem=CYCLUS_SHA1_SIZE;
28873  size_t total_item_size0=item_size1elem;
28874  unsigned int count0=0;
28875  for(;count0<buf.len;++count0){
28876  std::string x1elem=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
28877  x0.push_back(x1elem);
28878 
28879  }
28880  return x0;
28881 }
28882 template<>
28883 std::list<cyclus::Blob> Hdf5Back::VLBufToVal<std::list<cyclus::Blob>>(const hvl_t& buf) {
28884  std::list<cyclus::Blob> x0;
28885  char* p=reinterpret_cast<char*>(buf.p);
28886  size_t item_size1elem=CYCLUS_SHA1_SIZE;
28887  size_t total_item_size0=item_size1elem;
28888  unsigned int count0=0;
28889  for(;count0<buf.len;++count0){
28890  cyclus::Blob x1elem=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0));
28891  x0.push_back(x1elem);
28892 
28893  }
28894  return x0;
28895 }
28896 template<>
28897 std::list<boost::uuids::uuid> Hdf5Back::VLBufToVal<std::list<boost::uuids::uuid>>(const hvl_t& buf) {
28898  std::list<boost::uuids::uuid> x0;
28899  char* p=reinterpret_cast<char*>(buf.p);
28900  size_t item_size1elem=CYCLUS_UUID_SIZE;
28901  size_t total_item_size0=item_size1elem;
28902  unsigned int count0=0;
28903  for(;count0<buf.len;++count0){
28904  boost::uuids::uuid x1elem=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0));
28905  x0.push_back(x1elem);
28906 
28907  }
28908  return x0;
28909 }
28910 template<>
28911 std::map<int, bool> Hdf5Back::VLBufToVal<std::map<int, bool>>(const hvl_t& buf) {
28912  std::map<int, bool> x0;
28913  char* p=reinterpret_cast<char*>(buf.p);
28914  size_t item_size1key=sizeof(int);
28915  size_t item_size1val=sizeof(char);
28916  size_t total_item_size0=item_size1key+item_size1val;
28917  unsigned int count0=0;
28918  for(;count0<buf.len;++count0){
28919  int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28920  bool x1val=*reinterpret_cast<bool*>(p+(total_item_size0*count0)+item_size1key);
28921  x0[x1key] = x1val;
28922 
28923  }
28924  return x0;
28925 }
28926 template<>
28927 std::map<int, int> Hdf5Back::VLBufToVal<std::map<int, int>>(const hvl_t& buf) {
28928  std::map<int, int> x0;
28929  char* p=reinterpret_cast<char*>(buf.p);
28930  size_t item_size1key=sizeof(int);
28931  size_t item_size1val=sizeof(int);
28932  size_t total_item_size0=item_size1key+item_size1val;
28933  unsigned int count0=0;
28934  for(;count0<buf.len;++count0){
28935  int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28936  int x1val=*reinterpret_cast<int*>(p+(total_item_size0*count0)+item_size1key);
28937  x0[x1key] = x1val;
28938 
28939  }
28940  return x0;
28941 }
28942 template<>
28943 std::map<int, float> Hdf5Back::VLBufToVal<std::map<int, float>>(const hvl_t& buf) {
28944  std::map<int, float> x0;
28945  char* p=reinterpret_cast<char*>(buf.p);
28946  size_t item_size1key=sizeof(int);
28947  size_t item_size1val=sizeof(float);
28948  size_t total_item_size0=item_size1key+item_size1val;
28949  unsigned int count0=0;
28950  for(;count0<buf.len;++count0){
28951  int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28952  float x1val=*reinterpret_cast<float*>(p+(total_item_size0*count0)+item_size1key);
28953  x0[x1key] = x1val;
28954 
28955  }
28956  return x0;
28957 }
28958 template<>
28959 std::map<int, double> Hdf5Back::VLBufToVal<std::map<int, double>>(const hvl_t& buf) {
28960  std::map<int, double> x0;
28961  char* p=reinterpret_cast<char*>(buf.p);
28962  size_t item_size1key=sizeof(int);
28963  size_t item_size1val=sizeof(double);
28964  size_t total_item_size0=item_size1key+item_size1val;
28965  unsigned int count0=0;
28966  for(;count0<buf.len;++count0){
28967  int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28968  double x1val=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size1key);
28969  x0[x1key] = x1val;
28970 
28971  }
28972  return x0;
28973 }
28974 template<>
28975 std::map<int, std::string> Hdf5Back::VLBufToVal<std::map<int, std::string>>(const hvl_t& buf) {
28976  std::map<int, std::string> x0;
28977  char* p=reinterpret_cast<char*>(buf.p);
28978  size_t item_size1key=sizeof(int);
28979  size_t item_size1val=CYCLUS_SHA1_SIZE;
28980  size_t total_item_size0=item_size1key+item_size1val;
28981  unsigned int count0=0;
28982  for(;count0<buf.len;++count0){
28983  int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
28984  std::string x1val=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size1key);
28985  x0[x1key] = x1val;
28986 
28987  }
28988  return x0;
28989 }
28990 template<>
28991 std::map<int, cyclus::Blob> Hdf5Back::VLBufToVal<std::map<int, cyclus::Blob>>(const hvl_t& buf) {
28992  std::map<int, cyclus::Blob> x0;
28993  char* p=reinterpret_cast<char*>(buf.p);
28994  size_t item_size1key=sizeof(int);
28995  size_t item_size1val=CYCLUS_SHA1_SIZE;
28996  size_t total_item_size0=item_size1key+item_size1val;
28997  unsigned int count0=0;
28998  for(;count0<buf.len;++count0){
28999  int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29000  cyclus::Blob x1val=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0)+item_size1key);
29001  x0[x1key] = x1val;
29002 
29003  }
29004  return x0;
29005 }
29006 template<>
29007 std::map<int, boost::uuids::uuid> Hdf5Back::VLBufToVal<std::map<int, boost::uuids::uuid>>(const hvl_t& buf) {
29008  std::map<int, boost::uuids::uuid> x0;
29009  char* p=reinterpret_cast<char*>(buf.p);
29010  size_t item_size1key=sizeof(int);
29011  size_t item_size1val=CYCLUS_UUID_SIZE;
29012  size_t total_item_size0=item_size1key+item_size1val;
29013  unsigned int count0=0;
29014  for(;count0<buf.len;++count0){
29015  int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29016  boost::uuids::uuid x1val=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0)+item_size1key);
29017  x0[x1key] = x1val;
29018 
29019  }
29020  return x0;
29021 }
29022 template<>
29023 std::map<std::string, bool> Hdf5Back::VLBufToVal<std::map<std::string, bool>>(const hvl_t& buf) {
29024  std::map<std::string, bool> x0;
29025  char* p=reinterpret_cast<char*>(buf.p);
29026  size_t item_size1key=CYCLUS_SHA1_SIZE;
29027  size_t item_size1val=sizeof(char);
29028  size_t total_item_size0=item_size1key+item_size1val;
29029  unsigned int count0=0;
29030  for(;count0<buf.len;++count0){
29031  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29032  bool x1val=*reinterpret_cast<bool*>(p+(total_item_size0*count0)+item_size1key);
29033  x0[x1key] = x1val;
29034 
29035  }
29036  return x0;
29037 }
29038 template<>
29039 std::map<std::string, int> Hdf5Back::VLBufToVal<std::map<std::string, int>>(const hvl_t& buf) {
29040  std::map<std::string, int> x0;
29041  char* p=reinterpret_cast<char*>(buf.p);
29042  size_t item_size1key=CYCLUS_SHA1_SIZE;
29043  size_t item_size1val=sizeof(int);
29044  size_t total_item_size0=item_size1key+item_size1val;
29045  unsigned int count0=0;
29046  for(;count0<buf.len;++count0){
29047  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29048  int x1val=*reinterpret_cast<int*>(p+(total_item_size0*count0)+item_size1key);
29049  x0[x1key] = x1val;
29050 
29051  }
29052  return x0;
29053 }
29054 template<>
29055 std::map<std::string, float> Hdf5Back::VLBufToVal<std::map<std::string, float>>(const hvl_t& buf) {
29056  std::map<std::string, float> x0;
29057  char* p=reinterpret_cast<char*>(buf.p);
29058  size_t item_size1key=CYCLUS_SHA1_SIZE;
29059  size_t item_size1val=sizeof(float);
29060  size_t total_item_size0=item_size1key+item_size1val;
29061  unsigned int count0=0;
29062  for(;count0<buf.len;++count0){
29063  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29064  float x1val=*reinterpret_cast<float*>(p+(total_item_size0*count0)+item_size1key);
29065  x0[x1key] = x1val;
29066 
29067  }
29068  return x0;
29069 }
29070 template<>
29071 std::map<std::string, double> Hdf5Back::VLBufToVal<std::map<std::string, double>>(const hvl_t& buf) {
29072  std::map<std::string, double> x0;
29073  char* p=reinterpret_cast<char*>(buf.p);
29074  size_t item_size1key=CYCLUS_SHA1_SIZE;
29075  size_t item_size1val=sizeof(double);
29076  size_t total_item_size0=item_size1key+item_size1val;
29077  unsigned int count0=0;
29078  for(;count0<buf.len;++count0){
29079  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29080  double x1val=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size1key);
29081  x0[x1key] = x1val;
29082 
29083  }
29084  return x0;
29085 }
29086 template<>
29087 std::map<std::string, std::string> Hdf5Back::VLBufToVal<std::map<std::string, std::string>>(const hvl_t& buf) {
29088  std::map<std::string, std::string> x0;
29089  char* p=reinterpret_cast<char*>(buf.p);
29090  size_t item_size1key=CYCLUS_SHA1_SIZE;
29091  size_t item_size1val=CYCLUS_SHA1_SIZE;
29092  size_t total_item_size0=item_size1key+item_size1val;
29093  unsigned int count0=0;
29094  for(;count0<buf.len;++count0){
29095  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29096  std::string x1val=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size1key);
29097  x0[x1key] = x1val;
29098 
29099  }
29100  return x0;
29101 }
29102 template<>
29103 std::map<std::string, cyclus::Blob> Hdf5Back::VLBufToVal<std::map<std::string, cyclus::Blob>>(const hvl_t& buf) {
29104  std::map<std::string, cyclus::Blob> x0;
29105  char* p=reinterpret_cast<char*>(buf.p);
29106  size_t item_size1key=CYCLUS_SHA1_SIZE;
29107  size_t item_size1val=CYCLUS_SHA1_SIZE;
29108  size_t total_item_size0=item_size1key+item_size1val;
29109  unsigned int count0=0;
29110  for(;count0<buf.len;++count0){
29111  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29112  cyclus::Blob x1val=VLRead<cyclus::Blob,BLOB>(p+(total_item_size0*count0)+item_size1key);
29113  x0[x1key] = x1val;
29114 
29115  }
29116  return x0;
29117 }
29118 template<>
29119 std::map<std::string, boost::uuids::uuid> Hdf5Back::VLBufToVal<std::map<std::string, boost::uuids::uuid>>(const hvl_t& buf) {
29120  std::map<std::string, boost::uuids::uuid> x0;
29121  char* p=reinterpret_cast<char*>(buf.p);
29122  size_t item_size1key=CYCLUS_SHA1_SIZE;
29123  size_t item_size1val=CYCLUS_UUID_SIZE;
29124  size_t total_item_size0=item_size1key+item_size1val;
29125  unsigned int count0=0;
29126  for(;count0<buf.len;++count0){
29127  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29128  boost::uuids::uuid x1val=*reinterpret_cast<boost::uuids::uuid*>(p+(total_item_size0*count0)+item_size1key);
29129  x0[x1key] = x1val;
29130 
29131  }
29132  return x0;
29133 }
29134 template<>
29135 std::map<std::pair<int, std::string>, double> Hdf5Back::VLBufToVal<std::map<std::pair<int, std::string>, double>>(const hvl_t& buf) {
29136  std::map<std::pair<int, std::string>, double> x0;
29137  char* p=reinterpret_cast<char*>(buf.p);
29138  size_t item_size2keyfirst=sizeof(int);
29139  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
29140  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
29141  size_t item_size1key=total_item_size1key;
29142  size_t item_size1val=sizeof(double);
29143  size_t total_item_size0=item_size1key+item_size1val;
29144  unsigned int count0=0;
29145  for(;count0<buf.len;++count0){
29146  std::pair<int, std::string> x1key;
29147  int x2keyfirst=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29148  std::string x2keysecond=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size2keyfirst);
29149  x1key = std::make_pair(x2keyfirst,x2keysecond);
29150  double x1val=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size1key);
29151  x0[x1key] = x1val;
29152 
29153  }
29154  return x0;
29155 }
29156 template<>
29157 std::map<std::string, std::vector<double>> Hdf5Back::VLBufToVal<std::map<std::string, std::vector<double>>>(const hvl_t& buf) {
29158  std::map<std::string, std::vector<double>> x0;
29159  char* p=reinterpret_cast<char*>(buf.p);
29160  size_t item_size1key=CYCLUS_SHA1_SIZE;
29161  size_t item_size1val=CYCLUS_SHA1_SIZE;
29162  size_t total_item_size0=item_size1key+item_size1val;
29163  unsigned int count0=0;
29164  for(;count0<buf.len;++count0){
29165  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29166  std::vector<double> x1val=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(p+(total_item_size0*count0)+item_size1key);
29167  x0[x1key] = x1val;
29168 
29169  }
29170  return x0;
29171 }
29172 template<>
29173 std::map<std::string, std::map<int, double>> Hdf5Back::VLBufToVal<std::map<std::string, std::map<int, double>>>(const hvl_t& buf) {
29174  std::map<std::string, std::map<int, double>> x0;
29175  char* p=reinterpret_cast<char*>(buf.p);
29176  size_t item_size1key=CYCLUS_SHA1_SIZE;
29177  size_t item_size1val=CYCLUS_SHA1_SIZE;
29178  size_t total_item_size0=item_size1key+item_size1val;
29179  unsigned int count0=0;
29180  for(;count0<buf.len;++count0){
29181  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29182  std::map<int, double> x1val=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(p+(total_item_size0*count0)+item_size1key);
29183  x0[x1key] = x1val;
29184 
29185  }
29186  return x0;
29187 }
29188 template<>
29189 std::map<std::string, std::pair<double, std::map<int, double>>> Hdf5Back::VLBufToVal<std::map<std::string, std::pair<double, std::map<int, double>>>>(const hvl_t& buf) {
29190  std::map<std::string, std::pair<double, std::map<int, double>>> x0;
29191  char* p=reinterpret_cast<char*>(buf.p);
29192  size_t item_size2valfirst=sizeof(double);
29193  size_t item_size2valsecond=CYCLUS_SHA1_SIZE;
29194  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
29195  size_t item_size1key=CYCLUS_SHA1_SIZE;
29196  size_t item_size1val=total_item_size1val;
29197  size_t total_item_size0=item_size1key+item_size1val;
29198  unsigned int count0=0;
29199  for(;count0<buf.len;++count0){
29200  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29201  std::pair<double, std::map<int, double>> x1val;
29202  double x2valfirst=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size1key);
29203  std::map<int, double> x2valsecond=VLRead<std::map<int, double>,VL_MAP_INT_DOUBLE>(p+(total_item_size0*count0)+item_size1key+item_size2valfirst);
29204  x1val = std::make_pair(x2valfirst,x2valsecond);
29205  x0[x1key] = x1val;
29206 
29207  }
29208  return x0;
29209 }
29210 template<>
29211 std::map<int, std::map<std::string, double>> Hdf5Back::VLBufToVal<std::map<int, std::map<std::string, double>>>(const hvl_t& buf) {
29212  std::map<int, std::map<std::string, double>> x0;
29213  char* p=reinterpret_cast<char*>(buf.p);
29214  size_t item_size1key=sizeof(int);
29215  size_t item_size1val=CYCLUS_SHA1_SIZE;
29216  size_t total_item_size0=item_size1key+item_size1val;
29217  unsigned int count0=0;
29218  for(;count0<buf.len;++count0){
29219  int x1key=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29220  std::map<std::string, double> x1val=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(p+(total_item_size0*count0)+item_size1key);
29221  x0[x1key] = x1val;
29222 
29223  }
29224  return x0;
29225 }
29226 template<>
29227 std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> Hdf5Back::VLBufToVal<std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>>>(const hvl_t& buf) {
29228  std::map<std::string, std::vector<std::pair<int, std::pair<std::string, std::string>>>> x0;
29229  char* p=reinterpret_cast<char*>(buf.p);
29230  size_t item_size1key=CYCLUS_SHA1_SIZE;
29231  size_t item_size1val=CYCLUS_SHA1_SIZE;
29232  size_t total_item_size0=item_size1key+item_size1val;
29233  unsigned int count0=0;
29234  for(;count0<buf.len;++count0){
29235  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29236  std::vector<std::pair<int, std::pair<std::string, std::string>>> x1val=VLRead<std::vector<std::pair<int, std::pair<std::string, std::string>>>,VL_VECTOR_PAIR_INT_PAIR_VL_STRING_VL_STRING>(p+(total_item_size0*count0)+item_size1key);
29237  x0[x1key] = x1val;
29238 
29239  }
29240  return x0;
29241 }
29242 template<>
29243 std::list<std::pair<int, int>> Hdf5Back::VLBufToVal<std::list<std::pair<int, int>>>(const hvl_t& buf) {
29244  std::list<std::pair<int, int>> x0;
29245  char* p=reinterpret_cast<char*>(buf.p);
29246  size_t item_size2elemfirst=sizeof(int);
29247  size_t item_size2elemsecond=sizeof(int);
29248  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
29249  size_t item_size1elem=total_item_size1elem;
29250  size_t total_item_size0=item_size1elem;
29251  unsigned int count0=0;
29252  for(;count0<buf.len;++count0){
29253  std::pair<int, int> x1elem;
29254  int x2elemfirst=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29255  int x2elemsecond=*reinterpret_cast<int*>(p+(total_item_size0*count0)+item_size2elemfirst);
29256  x1elem = std::make_pair(x2elemfirst,x2elemsecond);
29257  x0.push_back(x1elem);
29258 
29259  }
29260  return x0;
29261 }
29262 template<>
29263 std::map<std::string, std::pair<std::string, std::vector<double>>> Hdf5Back::VLBufToVal<std::map<std::string, std::pair<std::string, std::vector<double>>>>(const hvl_t& buf) {
29264  std::map<std::string, std::pair<std::string, std::vector<double>>> x0;
29265  char* p=reinterpret_cast<char*>(buf.p);
29266  size_t item_size2valfirst=CYCLUS_SHA1_SIZE;
29267  size_t item_size2valsecond=CYCLUS_SHA1_SIZE;
29268  size_t total_item_size1val=item_size2valfirst+item_size2valsecond;
29269  size_t item_size1key=CYCLUS_SHA1_SIZE;
29270  size_t item_size1val=total_item_size1val;
29271  size_t total_item_size0=item_size1key+item_size1val;
29272  unsigned int count0=0;
29273  for(;count0<buf.len;++count0){
29274  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29275  std::pair<std::string, std::vector<double>> x1val;
29276  std::string x2valfirst=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size1key);
29277  std::vector<double> x2valsecond=VLRead<std::vector<double>,VL_VECTOR_DOUBLE>(p+(total_item_size0*count0)+item_size1key+item_size2valfirst);
29278  x1val = std::make_pair(x2valfirst,x2valsecond);
29279  x0[x1key] = x1val;
29280 
29281  }
29282  return x0;
29283 }
29284 template<>
29285 std::map<std::string, std::map<std::string, int>> Hdf5Back::VLBufToVal<std::map<std::string, std::map<std::string, int>>>(const hvl_t& buf) {
29286  std::map<std::string, std::map<std::string, int>> x0;
29287  char* p=reinterpret_cast<char*>(buf.p);
29288  size_t item_size1key=CYCLUS_SHA1_SIZE;
29289  size_t item_size1val=CYCLUS_SHA1_SIZE;
29290  size_t total_item_size0=item_size1key+item_size1val;
29291  unsigned int count0=0;
29292  for(;count0<buf.len;++count0){
29293  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29294  std::map<std::string, int> x1val=VLRead<std::map<std::string, int>,VL_MAP_VL_STRING_INT>(p+(total_item_size0*count0)+item_size1key);
29295  x0[x1key] = x1val;
29296 
29297  }
29298  return x0;
29299 }
29300 template<>
29301 std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> Hdf5Back::VLBufToVal<std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>>>(const hvl_t& buf) {
29302  std::vector<std::pair<std::pair<double, double>, std::map<std::string, double>>> x0;
29303  char* p=reinterpret_cast<char*>(buf.p);
29304  size_t item_size3elemfirstfirst=sizeof(double);
29305  size_t item_size3elemfirstsecond=sizeof(double);
29306  size_t total_item_size2elemfirst=item_size3elemfirstfirst+item_size3elemfirstsecond;
29307  size_t item_size2elemfirst=total_item_size2elemfirst;
29308  size_t item_size2elemsecond=CYCLUS_SHA1_SIZE;
29309  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
29310  size_t item_size1elem=total_item_size1elem;
29311  size_t total_item_size0=item_size1elem;
29312  unsigned int count0=0;
29313  for(;count0<buf.len;++count0){
29314  std::pair<std::pair<double, double>, std::map<std::string, double>> x1elem;
29315  std::pair<double, double> x2elemfirst;
29316  double x3elemfirstfirst=*reinterpret_cast<double*>(p+(total_item_size0*count0));
29317  double x3elemfirstsecond=*reinterpret_cast<double*>(p+(total_item_size0*count0)+item_size3elemfirstfirst);
29318  x2elemfirst = std::make_pair(x3elemfirstfirst,x3elemfirstsecond);
29319  std::map<std::string, double> x2elemsecond=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(p+(total_item_size0*count0)+item_size2elemfirst);
29320  x1elem = std::make_pair(x2elemfirst,x2elemsecond);
29321  x0.push_back(x1elem);
29322 
29323  }
29324  return x0;
29325 }
29326 template<>
29327 std::vector<std::pair<int, std::pair<std::string, std::string>>> Hdf5Back::VLBufToVal<std::vector<std::pair<int, std::pair<std::string, std::string>>>>(const hvl_t& buf) {
29328  std::vector<std::pair<int, std::pair<std::string, std::string>>> x0;
29329  char* p=reinterpret_cast<char*>(buf.p);
29330  size_t item_size3elemsecondfirst=CYCLUS_SHA1_SIZE;
29331  size_t item_size3elemsecondsecond=CYCLUS_SHA1_SIZE;
29332  size_t total_item_size2elemsecond=item_size3elemsecondfirst+item_size3elemsecondsecond;
29333  size_t item_size2elemfirst=sizeof(int);
29334  size_t item_size2elemsecond=total_item_size2elemsecond;
29335  size_t total_item_size1elem=item_size2elemfirst+item_size2elemsecond;
29336  size_t item_size1elem=total_item_size1elem;
29337  size_t total_item_size0=item_size1elem;
29338  unsigned int count0=0;
29339  for(;count0<buf.len;++count0){
29340  std::pair<int, std::pair<std::string, std::string>> x1elem;
29341  int x2elemfirst=*reinterpret_cast<int*>(p+(total_item_size0*count0));
29342  std::pair<std::string, std::string> x2elemsecond;
29343  std::string x3elemsecondfirst=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size2elemfirst);
29344  std::string x3elemsecondsecond=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size2elemfirst+item_size3elemsecondfirst);
29345  x2elemsecond = std::make_pair(x3elemsecondfirst,x3elemsecondsecond);
29346  x1elem = std::make_pair(x2elemfirst,x2elemsecond);
29347  x0.push_back(x1elem);
29348 
29349  }
29350  return x0;
29351 }
29352 template<>
29353 std::map<std::pair<std::string, std::string>, int> Hdf5Back::VLBufToVal<std::map<std::pair<std::string, std::string>, int>>(const hvl_t& buf) {
29354  std::map<std::pair<std::string, std::string>, int> x0;
29355  char* p=reinterpret_cast<char*>(buf.p);
29356  size_t item_size2keyfirst=CYCLUS_SHA1_SIZE;
29357  size_t item_size2keysecond=CYCLUS_SHA1_SIZE;
29358  size_t total_item_size1key=item_size2keyfirst+item_size2keysecond;
29359  size_t item_size1key=total_item_size1key;
29360  size_t item_size1val=sizeof(int);
29361  size_t total_item_size0=item_size1key+item_size1val;
29362  unsigned int count0=0;
29363  for(;count0<buf.len;++count0){
29364  std::pair<std::string, std::string> x1key;
29365  std::string x2keyfirst=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29366  std::string x2keysecond=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0)+item_size2keyfirst);
29367  x1key = std::make_pair(x2keyfirst,x2keysecond);
29368  int x1val=*reinterpret_cast<int*>(p+(total_item_size0*count0)+item_size1key);
29369  x0[x1key] = x1val;
29370 
29371  }
29372  return x0;
29373 }
29374 template<>
29375 std::map<std::string, std::map<std::string, double>> Hdf5Back::VLBufToVal<std::map<std::string, std::map<std::string, double>>>(const hvl_t& buf) {
29376  std::map<std::string, std::map<std::string, double>> x0;
29377  char* p=reinterpret_cast<char*>(buf.p);
29378  size_t item_size1key=CYCLUS_SHA1_SIZE;
29379  size_t item_size1val=CYCLUS_SHA1_SIZE;
29380  size_t total_item_size0=item_size1key+item_size1val;
29381  unsigned int count0=0;
29382  for(;count0<buf.len;++count0){
29383  std::string x1key=VLRead<std::string,VL_STRING>(p+(total_item_size0*count0));
29384  std::map<std::string, double> x1val=VLRead<std::map<std::string, double>,VL_MAP_VL_STRING_DOUBLE>(p+(total_item_size0*count0)+item_size1key);
29385  x0[x1key] = x1val;
29386 
29387  }
29388  return x0;
29389 }
29390 
29391 
29392 
29393 } // namespace cyclus
unsigned int val[CYCLUS_SHA1_NINT]
const Vals & vals()
Returns a vector of all field-value pairs that have been added to this datum.
Definition: datum.cc:56
std::string title()
Returns the datum&#39;s title as specified during the datum&#39;s creation.
Definition: datum.cc:52
const Shapes & shapes()
Returns a vector of all shapes (pointers to vectors of ints) that have been added to this datum...
Definition: datum.cc:60
virtual void Notify(DatumList data)
Used to pass a list of new/collected Datum objects.
Definition: hdf5_back.cc:77
Meta data and results of a query.
For values that are too big, too small, etc.
Definition: error.h:41
std::string name(int nuc)
Definition: pyne.cc:2940
Digest digest()
std::vector< Shape > Shapes
Definition: datum.h:22
DbTypes
This is the master list of all supported database types.
Definition: query_backend.h:31
def memcpy(dest, src, size)
#define CYCLUS_SHA1_NINT
Definition: query_backend.h:22
virtual void Flush()
Flushes all buffered data in the backend to its final format/location.
Definition: hdf5_back.h:91
virtual std::list< ColumnInfo > Schema(std::string table)
Return information about all columns of a table.
Definition: hdf5_back.cc:15123
Used to specify and send a collection of key-value pairs to the Recorder for recording.
Definition: datum.h:15
The digest type for SHA1s.
std::vector< boost::spirit::hold_any > QueryRow
def memset(dest, src, size)
virtual std::string Name()
Used to uniquely identify a backend - particularly if there are more than one in a simulation...
Definition: hdf5_back.cc:7662
for failed reading/writing to files, network connections, etc..
Definition: error.h:59
std::vector< std::string > fields
names of each field returned by a query
std::vector< Entry > Vals
Definition: datum.h:20
std::vector< int > Shape
Definition: datum.h:21
std::vector< DbTypes > types
types of each field returned by a query.
std::string field
table column name
virtual void Close()
Closes and flushes the backend.
Definition: hdf5_back.cc:41
Hdf5Back(std::string path)
Creates a new backend writing data to the specified file.
Definition: hdf5_back.cc:11
virtual std::map< std::string, DbTypes > ColumnTypes(std::string table)
Return a map of column names of the specified table to the associated database type.
Definition: hdf5_back.cc:15096
taken directly from OsiSolverInterface.cpp on 2/17/14 from https://projects.coin-or.org/Osi/browser/trunk.
Definition: agent.cc:14
A type to represent variable-length array of bytes for dumping to a cyclus output database...
Definition: blob.h:9
virtual ~Hdf5Back()
cleans up resources and closes the file.
Definition: hdf5_back.cc:72
std::vector< QueryRow > rows
ordered results of a query
Represents a condition used to filter rows returned by a query.
std::vector< T > cast() const
Casts the value of this digest to a vector of the templated type.
std::vector< Datum * > DatumList
Definition: rec_backend.h:12
virtual std::set< std::string > Tables()
Return a set of all table names currently in the database.
Definition: hdf5_back.cc:15155
virtual QueryResult Query(std::string table, std::vector< Cond > *conds)
Return a set of rows from the specificed table that match all given conditions.
Definition: hdf5_back.cc:163
int offset(int dz, int da, int ds=0)
A helper function to compute nuclide id offsets from z-, a-, and s- deltas.
Definition: pyne.h:1455
#define CYCLUS_SHA1_SIZE
Definition: query_backend.h:21
Represents column information.
void Clear()
Clears the current hash value to its default state.
void Update(const std::string &s)
Updates the hash value in-place.
#define CYCLUS_UUID_SIZE
Definition: query_backend.h:20